;==============================================================================================
; PSPad clip definition file for Free Pascal RTL library
;
; Autor: Andrzej Kowalski
; Last revision: 2005-10-25
; File version: 1.0
;
; Based on:
;
;   Source: PSPad clip definition file for Object Pascal
;   Autor: Borland Delphi 5
;   Last revision: 12-08-2001
; 
;   Source: FreePascal documentation
;   Autor: Michaėl Van Canneyt
;   Last revision: 05-2005
;
;==============================================================================================
;   Comments
;==============================================================================================
;   
;   Unified color schemes:
;
;       black   - Free Pascal language statements
;       gray    - Free Pascal compiler directives
;       navy    - Free Pascal laguage definitions
;       blue    - Free Pascal library functions and procedures
;       green   - Free Pascal library classes
;       purple  - Free Pascal library types
;       fuchsia - Free Pascal library variables
;       red     - Free Pascal library constants
;       maroon  - user defined constructions
;
;   Units incorporated in this file:
;
;       Pascal Language (including basic types, structured statements, 
;                        definition statements and procedure modifiers)
;       Pascal Compiler directives (with all possible switches)
;
;   and (including types, constants, variables, classes, functions and procedures)
;
;       Unit System
;       Unit Sysutils
;       Unit Dateutils
;       Unit Math
;       Unit Objpas
;       Unit Strings
;       Unit Strutils
;       Unit Typinfo
;       Unit Classes
;       Unit Dynlibs
;
;
;   Conventions:
;	
;	(type)		- result type of function (in function description)
;	(size: )	- size of variable of described type (in basic types description)
;   {? }		- function or procedure parameters description (in function description)
;   type1|type2	- passed parameters can be of type1 or type2
;	Name::		- name of unit which contains definition of this statement
;   optional    - optional parameter of given function or procedure; it indicates
;                 overloaded variants of given function rather than parameter with predefined 
;                 value
; 
;==============================================================================================

[Macro definition]
%OF%=@E Of:,
%FROM%=@E Bounds from:,
%TO%=@E Bounds to:,
%NAME%=@E Name:,
%TNAME%=@E Parent class name:,,TObject,
%COUNTER%=@E Counter name:,,i,
%RESULT%=@C Result type:,,,Integer;String;Boolean,
%PARAMS%=@E Parametres:,

%compileralign%=@C Type:,,POWER,MAC68K;POWER;RESET,
%compilerasmmode%=@C Type:,,INTEL,ATT;INTEL;DIRECT,
%compileronoff%=@C State:,,ON,ON;OFF,
%compilerfputype%=@C Type:,,X87,SOFT;X87;SSE;SSE2;SSE64;STANDARD;FPA;FPA10;FPA11;VFP;LIBGCC,
%compilerinterfaces%=@C Type:,,DEFAULT,DEFAULT;COM;CORBA,
%compilerinclude%=@C Type:,,DATE,FPCTARGET;FPCTARGETCPU;FPCTARGETOS;DATE;TIME;FILE;LINE,
%compilerfpuregisters%=@C Number:,,DEFAULT,NORMAL;DEFAULT;0;1;2;3;4;5;6;7,
%compileroutput%=@C Type:,,MASM,AS;AS_OUT;ASW;COFF;NASM;MASM;NASMCOFF;NASMELF;PECOFF;TASM,
%compilerpackenum%=@C Number:,,DEFAULT,NORMAL;DEFAULT;1;2;4,
%compilerz%=@C Number:,,4,1;2;4,
%compilerpackrecords%=@C Number:,,DEFAULT,NORMAL;DEFAULT;1;2;4;16;C,
%compilerapptype%=@C Type:,,GUI,CONSOLE;FS;GUI;TOOL,
%compilercalling%=@C Number:,,STDCALL,CDECL;CPPDECL;FPCCALL;FAR16;INLINE;PASCAL;REGISTER;SAFECALL;STDCALL;SOFTFLOAT,
%compilermode%=@C Type:,,OBJPAS,DEFAULT;DELPHI;OBJFPC;TP;GPC;FPC;MACPAS,

;==============================================================================================
; Pascal language
;==============================================================================================

[array |n array declaration (var)]
array[%From%..%To%] of %Of%;
|

[classf |n class declaration (all parts)]
%Name% = class(%TName%)
private
|
protected

public

published

end;
;
[classd |n class declaration (no parts)]
%Name% = class(%TName%)
|
end;
;
[classc |n class declaration (with Create/Destroy overrides)]
%Name% = class(%TName%)
private
|
protected

public
  constructor Create; override;
  destructor Destroy; override;
published

end;
;

[function |n function declaration]
function %Name%(%Params%): %Result%;
begin
|
end;
;

[procedure |n procedure declaration]
procedure %Name%(%Params%);
begin
  |
end;
;

[record |n record declaration]
§ = record
    | 
    end;

[recordv |n record declaration with variant part]
§ = record
    case (|) of
            
    end;
    
[unit |n unit definition template]
unit §;

interface
uses 
    { List of units goes here }
    { Interface section goes here }

implementation
uses 
    { List of units goes here }
    { Implementation section goes here }

initialization
    { Initialization section goes here }

finalization
    { Finalization section goes here }
end.

[program |n program definition template]
program §;
uses
    { List of used units goes here }
const
    { List of constants goes here }
type
    { List of types goes here }
var
    { List of variables goes here }
begin
    |
end.

[operator |n operator definition]
operator | (arg1 : type1; arg2 : type2) result : type3;
begin
    §
end;

[var |n variables declaration section]
var
    §|;
[type |n types declaration section]
type
    §|;
[const |n constant declaration section]
const
    §|;
[uses |n declare used units]
uses
    §|;

[case | case statement (with else)]
case | of
  |d ;
  |d ;
else ;
end;

[fors | for (no begin/end)]
for %Cunter% := %From% to %To% do
  §|

[forb | for statement]
§
for %Cunter% := %From% to %To% do
begin
  §|
end;
§

[ifs | if (no begin/end)]
if | then
  §
[ifb | if statement]
if | then begin
  §
end;
;
[ife | if then (no begin/end) else (no begin/end)]
if | then
  §
else
;
[ifeb | if then else]
if |
then begin
  §
end
else begin

end;
;
 
[trye | try except]
try
  §|
except

end;
;
[tryf | try finally]
try
  §|
finally

end;
;
[trycf | try finally (with Create/Free)]
%Name% := %TName%.Create;
try
  |
finally
  %Name%.Free;
end;
;
[whileb | while statement]
while | do begin
  §
end;
;
[whiles | while (no begin)]
while (|) do
;
[withb | with statement]
with (|) do begin
  §
end;
;
[withs | with (no begin)]
with | do
  §
;

[begin | begin ... end compound statement]
begin
    §|
end;

[repeat | repeat ... until loop statement]
repeat
    §
until (|);

[byte |p ordinal type 0 .. 255 (size 1 byte)]
§ : byte;
[shortint |p ordinal type -127 .. 127 (size 1 byte)]
§ : shortint;
[smallint |p ordinal type -32768 .. 32767 (size 2 bytes)]
§ : smallint;
[word |p ordinal type 0 .. 65535 (size 2 bytes)]
§ : word;
[integer  |p ordinal type either smallint, longint or int64 (size 2,4,8 bytes)]
§ : integer;
[cardinal |p ordinal type either word, longword or qword (size 2,4,8 bytes)]
§ : cardinal;
[longint |p ordinal type -2147483648 .. 2147483647 (size 4 bytes)]
§ : longint;
[longword |p ordinal type 0..4294967295 (size 4 bytes)]
§ : longword;
[int64 |p ordinal type -9223372036854775808 .. 9223372036854775807	(size 8 bytes)]
§ : int64;
[qword |p ordinal type 0 .. 18446744073709551615 (size 8 bytes)]
§ : qword;

[boolean |p FALSE = 0 TRUE = 1 	(size 1 byte)]
§ : boolean;
[bytebool |p FALSE = 0 TRUE = any nonzero value (size 1 byte)]
§ : bytebool;
[wordbool |p FALSE = 0 TRUE = any nonzero value (size 2 bytes)]
§ : wordbool;
[longbool |p FALSE = 0 TRUE = any nonzero value (size 4 bytes)]
§ : longbool;

[real |p real type platform dependant (size 4,8 bytes)]
§ : real;
[single |p real type 1.5E-45 .. 3.4E38 digits: 7-8 (size 4 bytes)]
§ : single;
[double |p real type 5.0E-324 .. 1.7E308 digits	15-16 (size 8 bytes)]
§ : double;
[extended |p real type	1.9E-4951 .. 1.1E4932 digits 19-20 (size 10 bytes)]
§ : extended;
[comp |p real type -2E64+1 .. 2E63-1 digits	19-20 (size 8 bytes)]
§ : comp;

[char |p character type the simpliest one (size 1 byte)]
§ : char;
[widechar |p character type contains unicode character (size 2 bytes)]
§ : widechar;
[string |p character type either shortstring or ansistring]
§ : string;
[stringl |p character type shortstring]
§ : string[|];
[widestring |p character type == array of widechar]
§ : widestring;
[ansistring |p character type == array of char]
§ : ansistring;
[shortstring |p character type == string(255)]
§ : shortstring;
[PChar |p character type null terminated string]
§ : PChar;
[variant |p variant type compatible with ordinal (enumerated), boolean, real, character variables and interfaces (COM objects)]
§ : variant;
[pointer |p generic pointer type]
§ : pointer;
[pointerv |p variable pointer type]
§ |d ^|; 
[set |p set type of ordinal type]
§ : set of |;
[file |p file type of no type]
§ : file;
[filet |p file type of any type]
§ : file of |;
[text | file type of char]
§ : text;

[;alias |d alias case sensitive name of procedure]
§; alias : '|';
[;cdecl |d declare a function that uses a C type calling convention]
§; cdecl; external name '|';
[;export |d used to export names when creating a shared library]
§; export; |
[;external |d used with cdecl to indicate function that resides in external object file library, can use also name or index parameters]
§; external '|' name '|';
[;inline |d procedures are copied to the places where they are called]
§; inline; |
[;interrupt |d routine which will be used as an interrupt handler]
§; interrupt; |
[;pascal |d procedure using standard pascal calling covention (passing parameters from left to right)]
§; pascal; |
[;popstack |d like cdecl but with popstack functions can be called by their pascal names in a library]
§; popstack; |
[;public |d defines function globally in a unit making it accessible form object file and not accessible from units]
§; public; |
[;saveregisters |d saves registers on procedure entry, and restores them when the procedure exits]
§; saveregisters; |
[;safecall |d like stdcall but also saves and restores all registers.]
§; safecall; |
[;softfloat |d used in ARM architecture]
§; softfloat; |
[;stdcall |d pushes the parameters from right to left on the stack, it also aligns all the parameters to a default alignment]
§; stdcall; |
[;varargs |d used only with cdecl and indicates procedure using variable number of arguments]
§; vargs; |
[;register |d three first aruments are passed into registers EAX,ECX and EDX (DELPHI compatibility)]
§; registers; |

[$A |d Align data ($MACPAS mode only)]
{$A %compileralign%}
|
[$ALIGN |d Align data same as $A ($MACPAS mode only)]
{$ALIGN %compileralign%}
|
[$ASMMODE |d Assembler mode (Intel 80x86 only)]
{$ASMMODE %compilerasmmode%}
|
[$B |d Complete boolean evaluation (TP compatibility)]
{$B+}
|
[$BOOLEVAL |d Complete boolean evaluation same as $B (TP compatibility)]
{$BOOLEVAL %compileronoff%}
|
[$ASSERTIONS |d Assertion support same as $C]
{$ASSERTIONS %compileronoff%}
|
[$C |d Assertion support]
{$C+}
|
[$CHECKPOINTER |d Check pointer values]
{$CHECKPOINTER %compileronoff%}
|
[$DEFINE |d Define a symbol]
{$DEFINE |}
[$ELSE |d Switch conditional compilation]
{$ELSE}
|
[$ELSEC |d Switch conditional compilation like $ELSE ($MACPAS mode only)]
{$ELSEC}
|
[$ENDC |d End conditional compilation like $ENDIF ($MACPAS mode only)]
{$ENDC}
|
[$ENDIF |d End conditional compilation]
{$ENDIF}
|
[$ERROR |d Generate error message]
{$ERROR |}
[$F |d Far or near functions (TP compatibility)]
{$F+}
|
[$FATAL |d Generate fatal error message]
{$FATAL |}
[$FPUTYPE |d Select coprocessor type (depends on processor type)]
{$FPUTYPE %compilerfputype%}
|
[$GOTO |d Support Goto and Label statements]
{$GOTO %compileronoff%}
|
[$LONGSTRINGS |d Use Strings as AnsiStrings same as $H]
{$LONGSTRINGS %compileronoff%}
|
[$H |d Use Strings as AnsiStrings]
{H+}
|
[$HINT |d Generate hint message]
{$HINT |}
[$HINTS |d Emit hints]
{$HINTS %compileronoff%}
|
[$IF |d Start conditional compilation depending on 'expression']
{$IF |}
[$IFC : Start conditional compilation like $IF ($MACPAS mode only)]
{$IFC |}
[$IFDEF |d Start conditional compilation depending on 'name' is defined]
{$IFDEF |}
[$IFNDEF |d Start conditional compilation depending on 'name' is not defined]
{$IFNDEF |}
[$IFOPT |d Start conditional compilation depending on 'compilator switch' state]
{$IFOPT |}
[$IMPLICITEXCEPTIONS |d Do not generate finalization code]
{$IMPLICITEXCEPTIONS %compileronoff%}
|
[$INFO |d Generate info message]
{$INFO |}
[$INLINE |d Allow inline code procedures]
{$INLINE %compileronoff%}
[$INTERFACES |d Specify Interface type.]
{$INTERFACES %compilerinterfaces%}
[$I |d Input/Output checking]
{$I+}
|
[$IOCHECKS |d Input/Output checking same as $I]
{$IOCHECKS %compileronoff%}
|
[$INCLUDE |d Include file]
{$INCLUDE |}
[$INCLUDE info |d Include compiler info]
{$INCLUDE %%compilerinclude%%}
|
[$I386_XXX |d Specify assembler format (Intel 80x86 only)
{$I386_%compilerasmmode%}
|
[$L |d Link object file]
{$L |}
[$LINK |d Link object file]
{$LINK |}
[$LINKLIB |d Link to a library]
{$LINKLIB |}
[$M |d Generate type info]
{$M+}
|
[$TYPEINFO |d Generate type info same as $M]
{$TYPEINFO %compileronoff%}
|
[$MACROS |d Allow use of macros.]
{$MACROS %compileronoff%}
|
[$MAXFPUREGISTERS |d Maximum number of FPU registers for variables]
{$MAXFPUREGISTERS %compilerfpuregisters%}
|
[$MESSAGE |d Generate info message]
{$MESSAGE |}
[$MMX |d Intel MMX support (Intel 80x86 only)]
{$MMX+}
|
[$NOTE |d Generate note message]
{$NOTE |}
[$NOTES |d Emit notes]
{$NOTES %compileronoff%}
|
[$OUTPUT_FORMAT |d Specify the output format]
{$OUTPUT_FORMAT %compileroutput%}
|
[$P |d Use open strings]
{$P+}
|
[$OPENSTRINGS |d Use open strings same as $P]
{$OPENSTRINGS %compileronoff%}
|
[$PACKENUM |d Minimum enumeration type size]
{$PACKENUM %compilerpackenum%}
|
[$MINENUMSIZE |d Minimum enumeration type size (DELPHI compatibility)]
{$MINENUMSIZE %compilerpackenum%}
|
[$Z |d Minimum enumeration type size (DELPHI compatibility)]
{$Z%compilerz%}
|
[$PACKRECORDS |d Alignment of record elements]
{$PACKRECORDS %compilerpackrecords%}
[$Q |d Overflow checking]
{$Q+}
|
[$OVERFLOWCHECKS |d Overflow checking same as $Q]
{$OVERFLOWCHECKS %compileronoff%}
|
[$R |d Range checking]
{$R+}
|
[$RANGECHECKS |d Range checking same as $R]
{$RANGECHECKS %compileronoff%}
|
[$SATURATION |d Saturation operations (Intel 80x86 only)]
{$SATURATION %compileronoff%}
|
[$SETC |d Define and assign a value to a symbol ($MACPAS mode only)]
{$SETC § := |}
|
[$STATIC |d Allow use of Static keyword]
{$STATIC %compileronoff%}
[$STOP |d Generate fatal error message]
{$STOP |}
[$T |d Typed address operator (@)]
{$T+}
|
[$TYPEDADDRESS |d Typed address operator (@) same as $T]
{$TYPEDADDRESS %compileronoff%}
|
[$UNDEF |d Undefine a symbol]
{$UNDEF |}
[$V |d Var-string checking]
{$V+}
|
[$VARSTRINGCHECKS |d Var-string checking same as $V]
{$VARSTRINGCHECKS %compileronoff%}
|
[$WAIT |d Wait for enter key press]
{$WAIT}
|
[$WARNING |d Generate warning message]
{$WARNING |}
[$WARNINGS |d Emit warnings]
{$WARNINGS %compileronoff%}
|
[$X |d Extended syntax]
{$X+}
|
[$EXTENDEDSYNTAX |d Extended syntax]
{$EXTENDEDSYNTAX %compileronoff%}
|
[$APPID |d Specify application ID (used on Palm os only)]
{$APPID |}
[$APPNAME |d Specify application name (used on Palm os only)]
{$APPNAME |}
[$APPTYPE |d Specify type of application.]
{$APPTYPE %compilerapptype%}
|
[$CALLING |d Default calling convention]
{$CALLING %compilercalling}
|
[$COPYRIGHT specify copyright info]
{$COPYRIGHT |}
[$D |d Debugging symbols]
{$D+}
|
[$DEBUGINFO |d Debugging symbols same as $D]
{$DEBUGINFO %compileronoff%}
|
[$DESCRIPTION |d Application description]
{$DESCRIPTION |}
[$E |d Emulation of coprocessor]
{$E+}
|
[$G |d Generate 80286 code (TP compatibility)]
{$G+}
|
[$INCLUDEPATH |d Specify include path.]
{$INCLUDEPATH |}
[$L |d Local symbol information (TP compatibility)]
{$L+}
|
[$LOCALSYMBOLS |d Local symbol information same as $L (TP compatibility)]
{$LOCALSYMBOLS %compileronoff%}
|
[$LIBRARYPATH |d Specify library path.]
{$LIBRARYPATH |}
[$M |d Memory sizes: StackSize,HeapSize]
{$M |}
[$MEMORY |d Memory sizes: StackSize,HeapSize]
{$MEMORY |}
[$MODE |d Set compiler compatibility mode]
{$MODE %compilermode%}
|
[$N |d Numeric processing (TP compatibility)]
{$N+}
|
[$O |d Overlay code generation (TP compatibility)]
{$O+}
|
[$OBJECTPATH |d Specify object path.]
{$OBJECTPATH |}
[$PROFILE |d Profiling]
{$PROFILE %compileronoff%}
|
[$S |d Stack checking]
{$S+}
|
[$SMARTLINK |d Use smartlinking]
{$SMARTLINK %compileronoff%}
|
[$THREADNAME |d Set thread name in Netware]
{$THREADNAME |}
[$THREADING |d Allow use of threads (TP compatibility)]
{$THREADING %compileronoff%}
|
[$UNITPATH |d Specify unit path.]
{$UNITPATH |}
[$VERSION |d Specify DLL version (at least 1, no more than 3 numbers).]
{$VERSION |}
[$W |d Generate stackframes]
{$W+}
|
[$STACKFRAMES |d Generate stackframes same as $W]
{$STACKFRAMES %compileronoff%}
|
[$Y |d Insert Browser information (DELPHI compatibility)]
{$Y+}
|
[$REFERENCEINFO |d Insert Browser information same as $Y (DELPHI compatibility)]
{$REFERENCEINFO %compileronoff%}
|

;==============================================================================================
;   Unit: Sysutils
;==============================================================================================
[Abort |b Sysutils:: Abort program execution.]
Abort
[AddDisk |b Sysutils:: Add a disk to the list of known disks (Unix only)]
AddDisk(§|) {? const path: String}
[AddTerminateProc |b Sysutils:: Add a procedure to the exit chain.]
AddTerminateProc(§|) {? TermProc: TTerminateProc}
[AdjustLineBreaks |b Sysutils:: Convert possible line-endings to the currently valid line ending (String).]
AdjustLineBreaks(§|,) {? const S: String; optional Style: TTextLineBreakStyle}
[AnsiCompareFileName |b Sysutils:: Compare 2 filenames (SizeInt).]
AnsiCompareFileName(§|,) {? const S1: String; const S2: String}
[AnsiCompareStr |b Sysutils:: Compare 2 ansistrings, case sensitive, ignoring accents characters (Integer).]
AnsiCompareStr(§|,) {? const S1: String; const S2: String}
[AnsiCompareText |b Sysutils:: Compare 2 ansistrings, case insensitive, ignoring accents characters (Integer).]
AnsiCompareText(§|,) {? const S1: String; const S2: String}
[AnsiExtractQuotedStr |b Sysutils:: Removes the first quoted string from a string (String).]
AnsiExtractQuotedStr(§|,) {? var Src: PChar; Quote: Char}
[AnsiLastChar |b Sysutils:: Return a pointer to the last character of a string (PChar).]
AnsiLastChar(§|) {? const S: String}
[AnsiLowerCase |b Sysutils:: Return a lowercase version of a string (String).]
AnsiLowerCase(§|) {? const s: String}
[AnsiLowerCaseFileName |b Sysutils:: Convert filename to lowercase (String).]
AnsiLowerCaseFileName(§|) {? const s: String}
[AnsiPos |b Sysutils:: Return Position of one ansistring in another (SizeInt).]
AnsiPos(§|,) {? const substr: String; const s: String}
[AnsiQuotedStr |b Sysutils:: Return a quoted version of a string (String).]
AnsiQuotedStr(§|,) {? const S: String; Quote: Char}
[AnsiSameStr |b Sysutils:: Checks whether 2 strings are the same (case sensitive) (Boolean)]
AnsiSameStr(§|,) {? const s1: String; const s2: String}
[AnsiSameText |b Sysutils:: Checks whether 2 strings are the same (case insensitive) (Boolean)]
AnsiSameText(§|,) {? const s1: String; const s2: String}
[AnsiStrComp |b Sysutils:: Compare two null-terminated strings. Case sensitive (Integer).]
AnsiStrComp(§|,) {? S1: PChar; S2: PChar}
[AnsiStrIComp |b Sysutils:: Compare two null-terminated strings. Case insensitive (Integer).]
AnsiStrIComp(§|,) {? S1: PChar; S2: PChar}
[AnsiStrLastChar |b Sysutils:: Return a pointer to the last character of a string (PChar).]
AnsiStrLastChar(§|) {? Str: PChar}
[AnsiStrLComp |b Sysutils:: Compare a limited number of characters of 2 strings (Integer)]
AnsiStrLComp(§|,,) {? S1: PChar; S2: PChar;M axLen: cardinal}
[AnsiStrLIComp |b Sysutils:: Compares a given number of characters of a string, case insensitive (Integer).]
AnsiStrLIComp(§|,,) {? S1: PChar; S2: PChar; MaxLen: cardinal}
[AnsiStrLower |b Sysutils:: Convert a null-terminated string to all-lowercase characters (PChar).]
AnsiStrLower(§|) {? Str: PChar}
[AnsiStrPos |b Sysutils:: Return position of one null-terminated substring in another (PChar)]
AnsiStrPos(§|,) {? str: PChar; substr: PChar}
[AnsiStrRScan |b Sysutils:: Find last occurrence of a character in a null-terminated string (PChar).]
AnsiStrRScan(§|,) {? Str: PChar; Chr: Char}
[AnsiStrScan |b Sysutils:: Find first occurrence of a character in a null-terminated string (PChar).]
AnsiStrScan(§|,) {? Str: PChar; Chr: Char}
[AnsiStrUpper |b Sysutils:: Convert a null-terminated string to all-uppercase characters (PChar).]
AnsiStrUpper(§|) {? Str: PChar}
[AnsiUpperCase |b Sysutils:: Return an uppercase version of a string, taking into account special characters (String).]
AnsiUpperCase(§|) {? const s: String}
[AnsiUpperCaseFileName |b Sysutils:: Convert filename to uppercase (String).]
AnsiUpperCaseFileName(§|) {? const s: String}
[AppendStr |b Sysutils:: Append one ansistring to another.]
AppendStr(§|,) {? var Dest: String; const S: String}
[ApplicationName |b Sysutils:: Return a default application name (String)]
ApplicationName
[AssignStr |b Sysutils:: Assigns an ansistring to a null-terminated string.]
AssignStr(§|,) {? var P: PString; const S: String}
[BCDToInt |b Sysutils:: Convert a BCD coded integer to a normal integer (Integer).]
BCDToInt(§|) {? Value: Integer}
[Beep |b Sysutils:: Sound the system bell.]
Beep
[BoolToStr |b Sysutils:: Convert a boolean value to a string (String).]
BoolToStr(§|) {? B: Boolean}
[ByteToCharIndex |b Sysutils:: Convert a character index in Bytes to an Index in characters (Integer)]
ByteToCharIndex(§|,) {? const S: String; Index: Integer}
[ByteToCharLen |b Sysutils:: Convert a length in bytes to a length in characters (Integer).]
ByteToCharLen(§|,) {? const S: String; MaxLen: Integer}
[ByteType |b Sysutils:: Return the type of byte in an ansistring for a multi-byte character set (TMbcsByteType)]
ByteType(§|,) {? const S: String; Index: Integer}
[CallTerminateProcs |b Sysutils:: Call the exit chain procedures (Boolean).]
CallTerminateProcs
[ChangeFileExt |b Sysutils:: Change the extension of a filename (String).]
ChangeFileExt(§|,) {? const FileName: String; const Extension: String}
[CharToByteLen |b Sysutils:: Convert a length in characters to a length in bytes (Integer).]
CharToByteLen(§|,) {? const S: String; MaxLen: Integer}
[CompareMem |b Sysutils:: Compare two memory areas (Boolean).]
CompareMem(§|,) {? P1: Pointer; P2: Pointer; Length: cardinal}
[CompareMemRange |b Sysutils:: Compare 2 memory locations (Integer)]
CompareMemRange(§|,) {? P1: Pointer; P2: Pointer; Length: cardinal}
[CompareStr |b Sysutils:: Compare 2 ansistrings case-sensitively, ignoring special characters (Integer).]
CompareStr(§|,) {? const S1: String; const S2: String}
[CompareText |b Sysutils:: Compare 2 ansistrings case insensitive (Integer).]
CompareText(§|,) {? const S1: String; const S2: String}
[CreateDir |b Sysutils:: Create a new directory (Boolean)]
CreateDir(§|) {? const NewDir: String}
[CurrToStr |b Sysutils:: Convert a currency value to a string (String).]
CurrToStr(§|) {? Value: Currency}
[Date |b Sysutils:: Return the current date (TDateTime).]
Date
[DateTimeToFileDate |b Sysutils:: Convert a TDateTime value to a file age (LongInt)]
DateTimeToFileDate(§|) {? DateTime: TDateTime}
[DateTimeToStr |b Sysutils:: Converts a TDateTime value to a string using a predefined format (String).]
DateTimeToStr(§|) {? DateTime: TDateTime}
[DateTimeToString |b Sysutils:: Converts a TDateTime value to a string with a given format.]
DateTimeToString(§|,,) {? var Result: String; const FormatStr: String; const DateTime: TDateTime}
[DateTimeToSystemTime |b Sysutils:: Converts a TDateTime value to a systemtime structure.]
DateTimeToSystemTime(§|,) {? DateTime: TDateTime; var SystemTime: TSystemTime}
[DateTimeToTimeStamp |b Sysutils:: Converts a TDateTime value to a TimeStamp structure (TTimeStamp).]
DateTimeToTimeStamp(§|) {? DateTime: TDateTime}
[DateToStr |b Sysutils:: Converts a TDateTime value to a date string with a predefined format (String).]
DateToStr(§|) {? Date: TDateTime}
[DayOfWeek |b Sysutils:: Returns the day of the week (Integer).]
DayOfWeek(§|) {? DateTime: TDateTime}
[DecodeDate |b Sysutils:: Decode a TDateTime to a year,month,day triplet]
DecodeDate(§|,,,) {? Date: TDateTime; var Year: Word; var Month: Word; var Day: Word}
[DecodeDateFully |b Sysutils:: Decode a date with additional date of the week (Boolean).]
DecodeDateFully(§|,,,,) {? const DateTime: TDateTime; var Year: Word; var Month: Word; var Day: Word; var DOW: Word}
[DecodeTime |b Sysutils:: Decode a TDateTime to a hour,minute,second,millisec quartet]
DecodeTime(§|,,,,) {? Time: TDateTime; var Hour: Word; var Minute: Word; var Second: Word; var MilliSecond: Word}
[DeleteFile |b Sysutils:: Delete a file from the filesystem (Boolean).]
DeleteFile(§|) {? const FileName: String}
[DirectoryExists |b Sysutils:: Check whether a directory exists in the file system (Boolean).]
DirectoryExists(§|) {? const Directory: String}
[DiskFree |b Sysutils:: Return the amount of free diskspace (Int64)]
DiskFree(§|) {? drive: Byte}
[DiskSize |b Sysutils:: Return the total amount of diskspace (Int64).]
DiskSize(§|) {? drive: Byte}
[DisposeStr |b Sysutils:: Dispose an ansistring from the heap.]
DisposeStr(§|) {? S: PString}
[DoDirSeparators |b Sysutils:: Convert known directory separators to the current directory separator.]
DoDirSeparators(§|) {? var FileName: String}
[EncodeDate |b Sysutils:: Encode a Year,Month,Day to a TDateTime value (TDateTime).] 
EncodeDate(§|,,) {? Year: Word; Month: Word; Day: Word}
[EncodeTime |b Sysutils:: Encode a Hour,Min,Sec,millisec to a TDateTime value (TDateTime).]
EncodeTime(§|,,,) {? Hour: Word; Minute: Word; Second: Word; MilliSecond: Word}
[ExceptAddr |b Sysutils:: Current exception address (Pointer).]
ExceptAddr 
[ExceptionErrorMessage |b Sysutils:: Return a message describing the exception (Integer).]
ExceptionErrorMessage(§|,,,) {? ExceptObject: TObject; ExceptAddr: Pointer; Buffer: PChar; Size: Integer}
[ExceptObject |b Sysutils:: Current Exception object (TObject).]
ExceptObject
[ExcludeTrailingBackslash |b Sysutils:: Strip trailing directory separator from a pathname, if needed (String).]
ExcludeTrailingBackslash(§|) {? const Path: String}
[ExcludeTrailingPathDelimiter |b Sysutils:: Strip trailing directory separator from a pathname, if needed (String).]
ExcludeTrailingPathDelimiter(§|) {? const Path: String}
[ExecuteProcess |b Sysutils:: Execute another process (program) (Integer).]
ExecuteProcess(§|,) {? const Path: AnsiString; const ComLine: AnsiString| Array[] of AnsiString}
[ExpandFileName |b Sysutils:: Expand a relative filename to an absolute filename (String).]
ExpandFileName(§|) {? const FileName: String}
[ExpandUNCFileName |b Sysutils:: Expand a relative filename to an absolute UNC filename (String).]
ExpandUNCFileName(§|) {? const FileName: String}
[ExtractFileDir |b Sysutils:: Extract the directory part of a filename (String).]
ExtractFileDir(§|) {? const FileName: String}
[ExtractFileDrive |b Sysutils:: Extract the drive part from a filename (String).]
ExtractFileDrive(§|) {? const FileName: String}
[ExtractFileExt |b Sysutils:: Return the extension from a filename (String).]
ExtractFileExt(§|) {? const FileName: String}
[ExtractFileName |b Sysutils:: Extract the filename part from a full path filename (String).]
ExtractFileName(§|) {? const FileName: String}
[ExtractFilePath |b Sysutils:: Extract the path from a filename (String).]
ExtractFilePath(§|) {? const FileName: String}
[ExtractRelativepath |b Sysutils:: Extract a relative path from a filename, given a base directory (String).]
ExtractRelativepath(§|,) {? const BaseName: String; const DestNAme: String}
[FileAge |b Sysutils:: Return the timestamp of a file (LongInt).]
FileAge(§|) {? const FileName: String}
[FileClose |b Sysutils:: Close a file handle.]
FileClose(§|) {? Handle: LongInt}
[FileCreate |b Sysutils:: Create a new file and return a handle to it (LongInt).]
FileCreate(§|,) {? const FileName: String; optional Mode: Integer}
[FileDateToDateTime |b Sysutils:: Convert a FileDate value to a TDateTime value (TDateTime).]
FileDateToDateTime(§|) {? Filedate: LongInt}
[FileExists |b Sysutils:: Check whether a file exists in the filesystem (Boolean).]
FileExists(§|) {? const FileName: String}
[FileGetAttr |b Sysutils:: Return attributes of a file (LongInt).]
FileGetAttr(§|) {? const FileName: String}
[FileGetDate |b Sysutils:: Return the file time of an opened file (LongInt).]
FileGetDate(§|) {? Handle: LongInt}
[FileIsReadOnly |b Sysutils:: Check whether a file is read-only (Boolean).]
FileIsReadOnly(§|) {? const FileName: String}
[FileOpen |b Sysutils:: Open an existing file and return a filehandle (LongInt)]
FileOpen(§|,) {? const FileName: String; Mode: Integer}
[FileRead |b Sysutils:: Read data from a filehandle in a buffer (LongInt).]
FileRead(§|,,) {? Handle: LongInt; var Buffer; Count: LongInt}
[FileSearch |b Sysutils:: Search for a file in a path.]
FileSearch(§|,) {? const Name: String; const DirList: String}
[FileSeek |b Sysutils:: Set the current file position on a file handle (LongInt|Int64).]
FileSeek(§|,,) {? Handle: LongInt; FOffset: LongInt|Int64; Origin: LongInt|Int64}
[FileSetAttr |b Sysutils:: Set the attributes of a file (LongInt).]
FileSetAttr(§|,) {? const Filename: String; Attr: LongInt}
[FileSetDate |b Sysutils:: Set the date of a file (LongInt).]
FileSetDate(§|,) {? Handle: LongInt; Age: LongInt}
[FileTruncate |b Sysutils:: Truncate an open file to a given size (Boolean).]
FileTruncate(§|,) {? Handle: LongInt; Size: LongInt}
[FileWrite |b Sysutils:: Write data from a buffer to a given filehandle (LongInt).]
FileWrite(§|,) {? Handle: LongInt; const Buffer;Count: LongInt}
[FindClose |b Sysutils:: Close a find handle]
FindClose(§|) {? var F: TSearchRec}
[FindCmdLineSwitch |b Sysutils:: Check whether a certain switch is present on the command-line (Boolean).]
FindCmdLineSwitch(§|,) {? const Switch: String; optional const Chars: TSysCharSet; optional IgnoreCase: Boolean}
[FindFirst |b Sysutils:: Start a file search and return a findhandle (LongInt)]
FindFirst(§|,,) {? const Path: String; Attr: LongInt; var Rslt: TSearchRec}
[FindNext |b Sysutils:: Find the next entry in a findhandle (LongInt).]
FindNext(§|) {? var Rslt: TSearchRec}
[FloattoCurr |b Sysutils:: Convert a float to a Currency value (Currency).]
FloattoCurr(§|) {? const Value: Extended}
[FloatToDateTime |b Sysutils:: Convert a float to a TDateTime value (TDateTime).]
FloatToDateTime(§|) {? const Value: Extended}
[FloatToDecimal |b Sysutils:: Convert a float value to a TFloatRec value.]
FloatToDecimal(§|,,,) {? var Result: TFloatRec; Value: Extended; Precision: Integer; Decimals: Integer}
[FloatToStr |b Sysutils:: Convert a float value to a string using a fixed format (String).]
FloatToStr(§|) {? Value: Extended}
[FloatToStrF |b Sysutils:: Convert a float value to a string using a given format (String).]
FloatToStrF(§|,,,) {? Value: Extended; format: TFloatFormat; Precision: Integer; Digits: Integer}
[FloatToText |b Sysutils:: Return a string representation of a float, with a given format (LongInt).]
FloatToText(§|,,,,) {? Buffer: PChar; Value: Extended; format: TFloatFormat; Precision: Integer; Digits: Integer} 
[FloatToTextFmt |b Sysutils:: Convert a float value to a string using a given mask (Integer).]
FloatToTextFmt(§|,,) {? Buffer: PChar; Value: Extended; format: PChar}
[FmtStr |b Sysutils:: Format a string with given arguments.]
FmtStr(§|,,) {? var Res: String; const Fmt: String; const args: Array[] of const}
[ForceDirectories |b Sysutils:: Create a chain of directories (Boolean)]
ForceDirectories(§|) {? const Dir: String}
[Format |b Sysutils:: Format a string with given arguments (String).]
Format(c§|,) {? onst Fmt: String; const Args: Array[] of const}
[FormatBuf |b Sysutils:: Format a string with given arguments and store the result in a buffer (Cardinal).]
FormatBuf(§|,,,) {? var Buffer; BufLen: Cardinal; const Fmt; fmtLen: Cardinal; const Args: Array[] of const}
[FormatCurr |b Sysutils:: Format a currency (String)]
FormatCurr(§|,) {? const Format: String; Value: Currency}
[FormatDateTime |b Sysutils:: Return a string representation of a TDateTime value with a given format (String).]
FormatDateTime(§|,) {? FormatStr: String; DateTime: TDateTime}
[FormatFloat |b Sysutils:: Format a float according to a certain mask (String).]
FormatFloat(§|,) {? const Format: String; Value: Extended}
[FreeAndNil |b Sysutils:: Free object if needed, and set object reference to Nil]
FreeAndNil(§|) {? var obj}
[GetAppConfigDir |b Sysutils:: Return the appropriate directory for the application's configuration files (String).]
GetAppConfigDir(§|) {? Global: Boolean}
[GetAppConfigFile |b Sysutils:: Return an appropriate name for an application configuration file (String).]
GetAppConfigFile(§|,) {? Global: Boolean; optional SubDir: Boolean}
[GetCurrentDir |b Sysutils:: Return the current working directory of the application (String).]
GetCurrentDir
[GetDirs |b Sysutils:: Return a list of directory names from a path (LongInt).]
GetDirs(§|,) {? var DirName: String; var Dirs: Array[] of pchar}
[GetEnvironmentString |b Sysutils:: Return an environment variable by index (String).]
GetEnvironmentString(§|) {? Index: Integer}
[GetEnvironmentVariable |b Sysutils:: Return the value of an environment variable (String).]
GetEnvironmentVariable(§|) {? const EnvVar: String}
[GetEnvironmentVariableCount |b Sysutils:: Return the number of variables in the environment.]
GetEnvironmentVariableCount
[GetFileHandle |b Sysutils:: Extract OS handle from an untyped file or text file (LongInt).]
GetFileHandle(§|) {? var f: File|Text}
[GetLastOSError |b Sysutils:: Return the last code from the OS (Integer).]
GetLastOSError
[GetLocalTime |b Sysutils:: Get the local time.]
GetLocalTime(§|) {? var SystemTime: TSystemTime}
[GetTempDir |b Sysutils:: Return name of system's temporary directory (String)]
GetTempDir(§|) {? optional Global: Boolean}
[GetTempFileName |b Sysutils:: Return the name of a temporary file (String).]
GetTempFileName(§|,) {? optional const Dir: String; optional const Prefix: String}
[IncludeTrailingBackslash |b Sysutils:: Add trailing directory separator to a pathname, if needed (String).]
IncludeTrailingBackslash(§|) {? const Path: String}
[IncludeTrailingPathDelimiter |b Sysutils:: Add trailing directory separator to a pathname, if needed (String).]
IncludeTrailingPathDelimiter(§|) {? const Path: String}
[IncMonth |b Sysutils:: Increases the month in a TDateTime value with a given amount (TDateTime).]
IncMonth(§|,) {? const DateTime: TDateTime; NumberOfMonths: Integer}
[InterLockedDecrement |b Sysutils:: Thread-safe integer decrement (LongInt)]
InterLockedDecrement(§|) {? var Target: LongInt}
[InterLockedExchange |b Sysutils:: Thread-safe exchange of 2 values (LongInt).]
InterLockedExchange(§|,) {? var Target: LongInt; Source: LongInt}
[InterLockedExchangeAdd |b Sysutils:: Thread-safe exchange of 2 values (LongInt)]
InterLockedExchangeAdd(§|,) {? var Target: LongInt; Source: LongInt}
[InterLockedIncrement |b Sysutils:: Thread-safe integer increment (LongInt).]
InterLockedIncrement(§|) {? var Target: LongInt}
[IntToHex |b Sysutils:: Convert an integer value to a hexadecimal string (String).]
IntToHex(§|,) {? Value: Integer|Int64; Digits: Integer}
[IntToStr |b Sysutils:: Convert an integer value to a decimal string (String).]
IntToStr(§|) {? Value: Integer|Int64|QWord}
[IsDelimiter |b Sysutils:: Check whether a given string is a delimiter character (Boolean).]
IsDelimiter(§|,,) {? const Delimiters: String; const S: String; Index: Integer}
[IsLeapYear |b Sysutils:: Determine whether a year is a leap year (Boolean).]
IsLeapYear(§|) {? Year: Word}
[IsPathDelimiter |b Sysutils:: Is the character at the given position a pathdelimiter (Boolean)]
IsPathDelimiter(§|,) {? const Path: String; Index: Integer}
[IsValidIdent |b Sysutils:: Check whether a string is a valid identifier name (Boolean).]
IsValidIdent(§|) {? const Ident: String}
[LastDelimiter |b Sysutils:: Return the last occurrence of a set of delimiters in a string (Integer).]
LastDelimiter(§|,) {? const Delimiters: String; const S: String}
[LeftStr |b Sysutils:: Return a number of characters starting at the left of a string (String).]
LeftStr(§|,) {? const S: String; Count: Integer}
[LoadStr |b Sysutils:: Load a string from the resource tables (String).]
LoadStr(§|) {? Ident: Integer}
[LowerCase |b Sysutils:: Return a lowercase version of a string (String).]
LowerCase(§|) {? const s: String}
[MSecsToTimeStamp |b Sysutils:: Convert a number of milliseconds to a TDateTime value (TTimeStamp).]
MSecsToTimeStamp(§|) {? MSecs: Comp}
[NewStr |b Sysutils:: Allocate a new ansistring on the heap (PString).]
NewStr(§|) {? const S: String}
[Now |b Sysutils:: Returns the current date and time (TDateTime).]
Now
[OutOfMemoryError |b Sysutils:: Raise an EOutOfMemory exception]
OutOfMemoryError
[QuotedStr |b Sysutils:: Return a quotes version of a string (String).]
QuotedStr(const S: String}
[RaiseLastOSError |b Sysutils:: Raise an exception with the last Operating System error code.]
RaiseLastOSError
[RemoveDir |b Sysutils:: Remove a directory from the filesystem (Boolean).]
RemoveDir(§|) {? const Dir: String}
[RenameFile |b Sysutils:: Rename a file (Boolean).]
RenameFile(§|,) {? const OldName: String; const NewName: String}
[RightStr |b Sysutils:: Return a number of characters from a string, starting at the end (String).]
RightStr(§|,) {? const S: String; Count: Integer}
[SameFileName |b Sysutils:: Are two filenames referring to the same file (Boolean)]
SameFileName(§|,) {? const S1: String; const S2: String}
[SameText |b Sysutils:: Checks whether 2 strings are the same (case insensitive) (Boolean)]
SameText(§|,) {? const s1: String; const s2: String}
[SetCurrentDir |b Sysutils:: Set the current directory of the application (Boolean).]
SetCurrentDir(§|) {? const NewDir: String}
[SetDirSeparators |b Sysutils:: Set the directory separators to the known directory separators (String).]
SetDirSeparators(§|) {? const FileName: String}
[ShowException |b Sysutils:: Show the current exception to the user.]
ShowException(§|,) {? ExceptObject: TObject; ExceptAddr: Pointer}
[Sleep |b Sysutils:: Suspend execution of a program for a certain time.]
Sleep(§|) {? milliseconds: Cardinal}
[StrAlloc |b Sysutils:: Allocate a null-terminated string on the heap (PChar).]
StrAlloc(§|) {? Size: cardinal}
[StrBufSize |b Sysutils:: Return the size of a null-terminated string allocated on the heap (SizeUInt).]
StrBufSize(§|) {? Str: PChar}
[StrByteType |b Sysutils:: Return the type of byte in a null-terminated string for a multi-byte character set (TMbcsByteType)]
StrByteType(§|,) {? Str: PChar; Index: Cardinal}
[StrCat |b Sysutils:: Concatenate 2 null-terminated strings (PChar).]
StrCat(§|,) {? dest: pchar; source: pchar}
[StrCharLength |b Sysutils:: Return the length of a null-terminated string in characters (Integer).]
StrCharLength(§|) {? const Str: PChar}
[StrComp |b Sysutils:: Compare 2 null-terminated strings, case sensitive (SizeInt).]
StrComp(§|,) {? str1: pchar; str2: pchar}
[StrCopy |b Sysutils:: Copy a null-terminated string (PChar)]
StrCopy(§|,) {? dest: pchar; source: pchar}
[StrDispose |b Sysutils:: Dispose of a null-terminated string on the heap.]
StrDispose(§|) {? Str: PChar}
[StrECopy |b Sysutils:: Copy a null-terminated string, return a pointer to the end (PChar).]
StrECopy(§|,) {? dest: pchar; source: pchar}
[StrEnd |b Sysutils:: Return a pointer to the end of a null-terminated string (PChar)]
StrEnd(§|) {? p: pchar}
[StrFmt |b Sysutils:: Format a string with given arguments, store the result in a buffer (PChar).]
StrFmt(§|,) {? Buffer: PChar; Fmt: PChar; const args: Array[] of const}
[StriComp |b Sysutils:: Compare 2 null-terminated strings, case insensitive (SizeInt).]
StrIComp(§|,) {? str1: pchar; str2: pchar}
[StringReplace |b Sysutils:: Replace occurrences of one substring with another in a string (String).]
StringReplace(§|,,,) {? const S: String; const OldPattern: String; const NewPattern: String; Flags: TReplaceFlags}
[StrLCat |b Sysutils:: Concatenate 2 null-terminated strings, with length boundary (PChar).]
StrLCat(§|,,) {? dest: pchar; source: pchar; l: SizeInt}
[StrLComp |b Sysutils:: Compare limited number of characters of 2 null-terminated strings (SizeInt)]
StrLComp(§|,,) {? str1: pchar; str2: pchar; l: SizeInt}
[StrLCopy |b Sysutils:: Copy a null-terminated string, limited in length (PChar).]
StrLCopy(§|,,) {? dest: pchar; source: pchar; maxlen: SizeInt}
[StrLen |b Sysutils:: Length of a null-terminated string (SizeInt).]
StrLen(§|) {? p: pchar}
[StrLFmt |b Sysutils:: Format a string with given arguments, but with limited length (PChar).]
StrLFmt(§|,,,) {? Buffer: PCHar; Maxlen: Cardinal; Fmt: PChar; const args: Array[] of const}
[StrLiComp |b Sysutils:: Compare limited number of characters in 2 null-terminated strings, ignoring case (SizeInt).]
StrLiComp(§|,,) {? str1: pchar; str2: pchar; l: SizeInt}
[StrLower |b Sysutils:: Convert null-terminated string to all-lowercase (PChar).]
StrLower(§|) {? p: pchar}
[StrMove |b Sysutils:: Move a null-terminated string to new location (PChar).]
StrMove(§|,,) {? dest: pchar; source: pchar; l: SizeInt}
[StrNew |b Sysutils:: Allocate room for new null-terminated string (PChar).]
StrNew(§|) {? p: pchar}
[StrPas |b Sysutils:: Convert a null-terminated string to an ansistring (String).]
StrPas(§|) {? Str: PChar}
[StrPCopy |b Sysutils:: Copy an ansistring to a null-terminated string (PChar).]
StrPCopy(§|,) {? Dest: PChar; Source: String}
[StrPLCopy |b Sysutils:: Copy a limited number of characters from an ansistring to a null-terminated string (PChar).]
StrPLCopy(§|,,) {? Dest: PChar; Source: String; MaxLen: SizeUInt}
[StrPos |b Sysutils:: Find position of one null-terminated substring in another (PChar).]
StrPos(§|,) {? str1: pchar; str2: pchar}
[StrRScan |b Sysutils:: Find last occurrence of a character in a null-terminated string (PChar).]
StrRScan(§|,) {? p: pchar; c: Char}
[StrScan |b Sysutils:: Find first occurrence of a character in a null-terminated string (PChar).]
StrScan(§|,) {? p: pchar; c: Char}
[StrToBool |b Sysutils:: Convert a string to a boolean value (Boolean)]
StrToBool(§|) {? const S: String}
[StrToCurr |b Sysutils:: Convert a string to a currency value (Currency)]
StrToCurr(§|) {? const S: String}
[StrToCurrDef |b Sysutils:: Convert a string to a currency value, using a default value (Currency)]
StrToCurrDef(§|,) {? const S: String; Default: Currency}
[StrToDate |b Sysutils:: Convert a date string to a TDateTime value (TDateTime).]
StrToDate(§|) {? const S: String}
[StrToDateTime |b Sysutils:: Convert a date/time string to a TDateTime value (TDateTime).]
StrToDateTime(§|) {? const S: String}
[StrToFloat |b Sysutils:: Convert a string to a floating-point value (Extended).]
StrToFloat(§|) {? const S: String}
[StrToFloatDef |b Sysutils:: Convert a string to a float, with a default value (TDateTime).]
StrToFloatDef(§|,) {? const S: String; const Default: Extended}
[StrToInt |b Sysutils:: Convert a string to an integer value (Integer).]
StrToInt(§|) {? const s: String}
[StrToInt64 |b Sysutils:: Convert a string to an Int64 value (Int64).]
StrToInt64(§|) {? const s: String}
[StrToInt64Def |b Sysutils:: Convert a string to an Int64 value, with a default value (Int64)]
StrToInt64Def(§|,) {? const S: String; Default: Int64}
[StrToIntDef |b Sysutils:: Convert a string to an integer value, with a default value (Integer).]
StrToIntDef(§|,) {? const S: String; Default: Integer}
[StrToTime |b Sysutils:: Convert a time string to a TDateTime value (TDateTime).]
StrToTime(§|) {? const S: String}
[StrUpper |b Sysutils:: Convert null-terminated string to all-uppercase (PChar)]
StrUpper(§|) {? p: pchar}
[SysErrorMessage |b Sysutils:: Format a system error message (String).]
SysErrorMessage(§|) {? ErrorCode: Integer}
[SystemTimeToDateTime |b Sysutils:: Convert a system time to a TDateTime value (TDateTime).]
SystemTimeToDateTime(§|) {? const SystemTime: TSystemTime}
[TextToFloat |b Sysutils:: Convert a buffer to a float value (Boolean).]
TextToFloat(§|,,) {? Buffer: PChar; var Value: Extended|TAmorph; optional ValueType: TFloatValue}
[Time |b Sysutils:: Returns the current time (TDateTime).]
Time
[TimeStampToDateTime |b Sysutils:: Convert a TimeStamp value to a TDateTime value (TDateTime).]
TimeStampToDateTime(§|) {? const TimeStamp: TTimeStamp}
[TimeStampToMSecs |b Sysutils:: Converts a timestamp to a number of milliseconds (Comp).]
TimeStampToMSecs(§|) {? const TimeStamp: TTimeStamp}
[TimeToStr |b Sysutils:: Convert a TDateTime time to a string using a predefined format (String).]
TimeToStr(§|) {? Time: TDateTime}
[Trim |b Sysutils:: Trim whitespace from the ends of a string (String).]
Trim(§|) {? const S: String}
[TrimLeft |b Sysutils:: Trim whitespace from the beginning of a string (String).]
TrimLeft(§|) {? const S: String}
[TrimRight |b Sysutils:: Trim whitespace from the end of a string (String).]
TrimRight(§|) {? const S: String}
[TryEncodeDate |b Sysutils:: Try to encode a date, and indicate success (Boolean).]
TryEncodeDate(§|,,,) {? Year: Word; Month: Word; Day: Word; var Date: TDateTime}
[TryEncodeTime |b Sysutils:: Try to encode a time, and indicate success (Boolean).]
TryEncodeTime(§|,,,,) {? Hour: Word; Min: Word; Sec: Word; MSec: Word; var Time: TDateTime}
[TryFloatToCurr |b Sysutils:: Try to convert a float value to a currency value and report on success (Boolean).]
TryFloatToCurr(§|,) {? const Value: Extended; var AResult: Currency}
[TryStrToCurr |b Sysutils:: Try to convert a string to a currency (Boolean)]
TryStrToCurr(§|,) {? const S: String; var Value: Currency}
[TryStrToFloat |b Sysutils:: Try to convert a string to a float (Boolean).]
TryStrToFloat(§|,) {? const S: String; var Value: Single|Double}
[TryStrToInt |b Sysutils:: Try to convert a string to an integer, and report on success (Bool).]
TryStrToInt(§|,) {? const s: String; var i: Integer}
[TryStrToInt64 |b Sysutils:: Try to convert a string to an int64 value, and report on success (Boolean).]
TryStrToInt64(§|,) {? const s: String; var i: Int64}
[UpperCase |b Sysutils:: Return an uppercase version of a string (String).]
UpperCase(§|) {? const s: String}
[WideCompareStr |b Sysutils:: Compare two widestrings (case sensitive) (PtrInit)]
WideCompareStr(§|,) {? const s1: WideString; const s2: WideString}
[WideCompareText |b Sysutils:: Compare two widestrings (ignoring case) (PtrInit).]
WideCompareText(§|,) {? const s1: WideString; const s2: WideString}
[WideFmtStr |b Sysutils:: Widestring format]
WideFmtStr(§|,,) {? var Res: WideString; const Fmt: WideString; const args: Array[] of const}
[WideFormat |b Sysutils:: Format a wide string (WideString).]
WideFormat(§|,) {? const Fmt: WideString; const Args: Array[] of const}
[WideFormatBuf |b Sysutils:: Format widestring in a buffer (Cardinal).]
WideFormatBuf(§|,,,,) {? var Buffer; BufLen: Cardinal; const Fmt; fmtLen: Cardinal; const Args: Array[] of const}
[WideLowerCase |b Sysutils:: Change a widestring to all-lowercase (Widestring).]
WideLowerCase(§|) {? const s: WideString}
[WideSameStr |b Sysutils:: Check whether two widestrings are the same (case sensitive) (Boolean)]
WideSameStr(§|,) {? const s1: WideString; const s2: WideString}
[WideSameText |b Sysutils:: Check whether two widestrings are the same (ignoring case) (Boolean)]
WideSameText(§|,) {? const s1: WideString; const s2: WideString}
[WideUpperCase |b Sysutils:: Change a widestring to all-lowercase (WideString).]
WideUpperCase(§|) {? const s: WideString}
[WrapText |b Sysutils:: Word-wrap a text (String).]
WrapText(§|,,,) {? const Line: String; optional const BreakStr: String; optional const BreakChars: TSysCharSet; MaxCol: Integer}


[EAbort |g Sysutils:: Abort error.]
EAbort
[EAbstractError |g Sysutils:: Abstract error.]
EAbstractError
[EAccessViolation |g Sysutils:: Access Violation error]
EAccessViolation
[EAssertionFailed |g Sysutils:: Assertion failed error.]
EAssertionFailed
[EControlC |g Sysutils:: Control-C (abort) was pressed on the console.]
EControlC
[EConvertError |g Sysutils:: Conversion error.]
EConvertError
[EDivByZero |g Sysutils:: Division by zero error.]
EDivByZero
[EExternal |g Sysutils:: External Exception.]
EExternal
[EExternalException |g Sysutils:: External exception]
EExternalException
[EHeapMemoryError |g Sysutils:: Heap memory error]
EHeapMemoryError
[EInOutError |g Sysutils:: Input/Output error]
EInOutError
[EInterror |g Sysutils:: Integer operation error.]
EInterror
[EIntfCastError |g Sysutils:: Invalid interface cast error.]
EIntfCastError
[EIntOverflow |g Sysutils:: Integer overflow error.]
EIntOverflow
[EInvalidCast |g Sysutils:: Invalid typecast error.]
EInvalidCast
[EInvalidContainer |g Sysutils:: Invalid container error.]
EInvalidContainer
[EInvalidInsert |g Sysutils:: Invalid insert error.]
EInvalidInsert
[EInvalidOp |g Sysutils:: Invalid operation.]
EInvalidOp
[EInvalidPointer |g Sysutils:: Invalid pointer operation]
EInvalidPointer
[EMathError |g Sysutils:: Mathematical error]
EMathError
[ENoThreadSupport |g Sysutils:: No Thread support error.]
ENoThreadSupport
[EOSError |g Sysutils:: Operating system error.]
EOSError
[EOutOfMemory |g Sysutils:: Out of memory error.]
EOutOfMemory
[EOverflow |g Sysutils:: Float overflow error.]
EOverflow
[EPackageError |g Sysutils:: Package error.]
EPackageError
[EPrivilege |g Sysutils:: Privileged instruction error.]
EPrivilege
[EPropReadOnly |g Sysutils:: Read-only property error.]
EPropReadOnly
[EPropWriteOnly |g Sysutils:: Write-only property error.]
EPropWriteOnly
[ERangeError |g Sysutils:: Range check error.]
ERangeError
[ESafecallException |g Sysutils:: SafeCall exception.]
ESafecallException
[EStackOverflow |g Sysutils:: Stack overflow error.]
EStackOverflow
[EUnderflow |g Sysutils:: Float underflow error]
EUnderflow
[EVariantError |g Sysutils:: Variant error.]
EVariantError
[Exception |g Sysutils:: Base class of all exceptions.]
Exception
[EZeroDivide |g Sysutils:: Division by zero error.]
EZeroDivide


[LowerCaseTable |f Sysutils:: Table for conversion of characters to lowercase.]
LowerCaseTable
[OnGetApplicationName |f Sysutils:: Callback to get a customized application name.]
OnGetApplicationName
[OnGetTempDir |f Sysutils:: Handler for GetTempDir function.]
OnGetTempDir
[OnGetTempFile |f Sysutils:: Handler for GetTempFileName function.]
OnGetTempFile
[OnShowException |f Sysutils:: Callback to show unhandled exceptions.]
OnShowException
[SysLocale |f Sysutils:: Variable with locale information]
SysLocale
[UpperCaseTable |f Sysutils:: Table for conversion of characters to uppercase.]
UpperCaseTable


[ConfigExtension |r Sysutils:: Default application configuration file extension.]
ConfigExtension
[CurrencyDecimals |r Sysutils:: Number of decimals in currency amounts.]
CurrencyDecimals
[CurrencyFormat |r Sysutils:: Format string for currencies.]
CurrencyFormat
[CurrencyString |r Sysutils:: Name of currency.]
CurrencyString
[DateDelta |r Sysutils:: Days between 1/1/0001 and 12/31/1899]
DateDelta
[DateSeparator |r Sysutils:: Date separator character (subject to locale).]
DateSeparator
[DecimalSeparator |r Sysutils:: Decimal point separator.]
DecimalSeparator
[DefaultTextLineBreakStyle |r Sysutils:: Default line break style for the current platform.]
DefaultTextLineBreakStyle
[DirSeparators |r Sysutils:: Characters that are known directory separators.]
DirSeparators
[DriveDelim |r Sysutils:: Drive letter delimiter]
DriveDelim
[EmptyStr |r Sysutils:: Empty String Constant]
EmptyStr
[EmptyWideStr |r Sysutils:: Empty wide string.]
EmptyWideStr
[faAnyFile |r Sysutils:: Match any file]
faAnyFile
[faArchive |r Sysutils:: Archive bit is set]
faArchive
[faDirectory |r Sysutils:: File is a directory]
faDirectory
[faHidden |r Sysutils:: Hidden file.]
faHidden
[faReadOnly |r Sysutils:: Read-Only file.]
faReadOnly
[faSysFile |r Sysutils:: System file (Dos/Windows only)]
faSysFile
[faVolumeId |r Sysutils:: Volume id (Dos/Windows only)]
faVolumeId
[FileRecNameLength |r Sysutils:: Length of filerec filename field.]
FileRecNameLength
[fmOpenRead |r Sysutils:: Open file in read-only mode]
fmOpenRead
[fmOpenReadWrite |r Sysutils:: Open file in read/write mode.]
fmOpenReadWrite
[fmOpenWrite |r Sysutils:: Open file in write-only mode]
fmOpenWrite
[fmShareCompat |r Sysutils:: Open file in DOS share-compatibility mode]
fmShareCompat
[fmShareDenyNone |r Sysutils:: Do not lock file.]
fmShareDenyNone
[fmShareDenyRead |r Sysutils:: Lock file so other processes cannot read.]
fmShareDenyRead
[fmShareDenyWrite |r Sysutils:: Lock file so other processes can only read.]
fmShareDenyWrite
[fmShareExclusive |r Sysutils:: Lock file for exclusive use]
fmShareExclusive
[fsFromBeginning |r Sysutils:: Start seek operation from beginning of file.]
fsFromBeginning
[fsFromCurrent |r Sysutils:: Start seek operation from current position in file.]
fsFromCurrent
[fsFromEnd |r Sysutils:: Start seek operation from end of file.]
fsFromEnd
[HexDisplayPrefix |r Sysutils:: String to prepend to hexadecimal values]
HexDisplayPrefix
[HoursPerDay |r Sysutils:: Number of hours in a day.]
HoursPerDay
[LeadBytes |r Sysutils:: Lead bytes in Multi-Byte character sets]
LeadBytes
[LongDateFormat |r Sysutils:: Long date format string (subject to locale).]
LongDateFormat
[LongDayNames |r Sysutils:: Full names of days.]
LongDayNames
[LongMonthNames |r Sysutils:: Full names of months.]
LongMonthNames
[LongTimeFormat |r Sysutils:: Long time format string (subject to locale)]
LongTimeFormat
[MaxCurrency |r Sysutils:: Maximum currency value]
MaxCurrency
[MaxDateTime |r Sysutils:: Maximum TDateTime value.]
MaxDateTime
[Max_Path |r Sysutils:: ]
Max_Path
[MinCurrency |r Sysutils:: Minimum Currency value]
MinCurrency
[MinDateTime |r Sysutils:: Minimum TDateTime value.]
MinDateTime
[MinsPerDay |r Sysutils:: Number of minutes per day.]
MinsPerDay
[MinsPerHour |r Sysutils:: Number of minutes per hour.]
MinsPerHour
[MonthDays |r Sysutils:: Array with number of days in the months for leap and non-leap years.]
MonthDays
[MSecsPerDay |r Sysutils:: Number of milliseconds per day]
MSecsPerDay
[MSecsPerSec |r Sysutils:: Number of milliseconds per second]
MSecsPerSec
[NegCurrFormat |r Sysutils:: Format string for negative currencies.]
NegCurrFormat
[NullStr |r Sysutils:: Pointer to an empty string]
NullStr
[PathDelim |r Sysutils:: Path (directory) delimiter.]
PathDelim
[PathSep |r Sysutils:: Path separator. (Separates paths in search path lists)]
PathSep
[SecsPerDay |r Sysutils:: Number of seconds per day]
SecsPerDay
[SecsPerMin |r Sysutils:: Number of seconds per minute]
SecsPerMin
[ShortDateFormat |r Sysutils:: Short Date Format string (subject to locale).]
ShortDateFormat
[ShortDayNames |r Sysutils:: Names of days, abbreviated form.]
ShortDayNames
[ShortMonthNames |r Sysutils:: Names of months, abbreviated form.]
ShortMonthNames
[ShortTimeFormat |r Sysutils:: Short time format string (subject to locale).]
ShortTimeFormat
[SwitchChars |r Sysutils:: Characters which start a command-line switch]
SwitchChars
[SysConfigDir |r Sysutils:: System configuration directory.]
SysConfigDir
[TextRecBufSize |r Sysutils:: Buffer size of text file record.]
TextRecBufSize
[TextRecNameLength |r Sysutils:: Length of text file record filename field ]
TextRecNameLength
[ThousandSeparator |r Sysutils:: Thousand grouping character.]
ThousandSeparator
[TimeAMString |r Sysutils:: AM indicator string.]
TimeAMString
[TimePMString |r Sysutils:: PM indicator string.]
TimePMString
[TimeSeparator |r Sysutils:: Time separator character.]
TimeSeparator
[TwoDigitYearCenturyWindow |r Sysutils:: Window to determine what century 2 digit years are in.]
TwoDigitYearCenturyWindow
[UnixDateDelta |r Sysutils:: Number of days between 1.1.1900 and 1.1.1970]
UnixDateDelta


[EHeapException |p Sysutils:: Heap exception]
EHeapException
[ExceptClass |p Sysutils:: Exception Class reference]
ExceptClass
[FileRec |p Sysutils:: Record describing an untyped file.]
FileRec
[Int64Rec |p Sysutils:: Record describing an Int64 value]
Int64Rec
[LongRec |p Sysutils:: Record describing a longint value]
LongRec
[PByteArray |p Sysutils:: Pointer to an array of byte.]
PByteArray
[PDayTable |p Sysutils:: Pointer to TDayTable type.]
PDayTable
[PString |p Sysutils:: Pointer to a ansistring]
PString
[PWordarray |p Sysutils:: Pointer to an array of word.]
PWordarray
[TByteArray |p Sysutils:: Array of bytes]
TByteArray
[TCaseTranslationTable |p Sysutils:: Type for case conversion tables.]
TCaseTranslationTable
[TDayTable |p Sysutils:: Array of day names.]
TDayTable
[TextBuf |p Sysutils:: Text record buffer array type]
TextBuf
[TextRec |p Sysutils:: Record describing a text file type]
TextRec
[TFilename |p Sysutils:: Filename type]
TFilename
[TFileRec |p Sysutils:: Record describing an untyped file.]
TFileRec
[TFloatFormat |p Sysutils:: Formats for the FloatToText function.]
TFloatFormat
[TFloatRec |p Sysutils:: Record descriing a float value]
TFloatRec
[TFloatValue |p Sysutils:: Type of float to return in the buffer for TextToFloat.]
TFloatValue
[TGetAppNameEvent |p Sysutils:: Callback type to get customized application name.]
TGetAppNameEvent
[TGetTempDirEvent |p Sysutils:: Function prototype for OnGetTempDir handler.]
TGetTempDirEvent
[TGetTempFileEvent |p Sysutils:: Function prototype for OnGetTempFile handler.]
TGetTempFileEvent
[THandle |p Sysutils:: File Handle type.]
THandle
[TIntegerSet |p Sysutils:: Set with size of integer.]
TIntegerSet
[TLineEndStr |p Sysutils:: End-of-line string]
TLineEndStr
[TMbcsByteType |p Sysutils:: Type of multi-byte character set.]
TMbcsByteType
[TProcedure |p Sysutils:: Procedural type]
TProcedure
[TReplaceFlags |p Sysutils:: Flags for StringReplace function]
TReplaceFlags
[TSearchRec |p Sysutils:: Record describing a search handle or result ]
TSearchRec
[TSysCharSet |p Sysutils:: Set of characters.]
TSysCharSet
[TSysLocale |p Sysutils:: Type describing the current locale]
TSysLocale
[TSystemTime |p Sysutils:: System time structure]
TSystemTime
[TTerminateProc |p Sysutils:: Terminate procedure procedural variable.]
TTerminateProc
[TTextLineBreakStyle |p Sysutils:: Line break style]
TTextLineBreakStyle
[TTextRec |p Sysutils:: Record describing a text file.]
TTextRec
[TTimeStamp |p Sysutils:: TimeStamp structure]
TTimeStamp
[TWordArray |p Sysutils:: ]
TWordArray
[WordRec |p Sysutils:: Record describing a word value.]
WordRec


;==============================================================================================
;   Unit: System
;==============================================================================================

[AbstractErrorProc |r System:: Custom abstract error handling procedure]
AbstractErrorProc
[AssertErrorProc |r System:: Custom assert error handling procedure]
AssertErrorProc
[BackTraceStrFunc |r System:: Standard backtrace formatting routine]
BackTraceStrFunc
[CmdLine |r System:: Current command-line.]
CmdLine
[CtrlZMarksEOF |r System:: Determine whether CTRL-Z marks the end of file.]
CtrlZMarksEOF
[DefaultStackSize |r System:: Default size for a new thread's stack (32k by default).]
DefaultStackSize
[DefaultTextLineBreakStyle |r System:: Default line ending style.]
DefaultTextLineBreakStyle
[DirectorySeparator |r System:: Character used to separate directory parts.]
DirectorySeparator
[DriveSeparator |r System:: Character used to separate directory parts.]
DriveSeparator
[Erroraddr |r System:: Address where the last error occurred.]
Erroraddr
[Errorcode |r System:: Last error code.]
Errorcode
[ErrorProc |r System:: Custom error handling procedure.]
ErrorProc
[ExceptProc |r System:: Current exception handling procedure.]
ExceptProc
[ExitProc |r System:: Exit procedure pointer.]
ExitProc
[E_NOINTERFACE |r System:: Interface call result: Error: not an interface]
E_NOINTERFACE
[E_NOTIMPL |r System:: Interface call result: Interface not implemented]
E_NOTIMPL
[E_UNEXPECTED |r System:: Interface call result: Unexpected error]
E_UNEXPECTED
[Filemode |r System:: Default file mode for untyped files.]
Filemode
[FileNameCaseSensitive |r System:: OS treatment of filenames is case sensitive.]
FileNameCaseSensitive
[fmAppend |r System:: File mode: File is open for writing, appending to the end.]
fmAppend
[fmClosed |r System:: File mode: File is closed.]
fmClosed
[fmInOut |r System:: File mode: File is open for reading and writing.]
fmInOut
[fmInput |r System:: File mode: File is open for reading.]
fmInput
[fmOutput |r System:: File mode: File is open for writing.]
fmOutput
[fpc_in_abs_real |r System:: FPC compiler internal procedure index: abs (real) ]
fpc_in_abs_real
[fpc_in_addr_x |r System:: FPC compiler internal procedure index: addr ]
fpc_in_addr_x
[fpc_in_arctan_real |r System:: FPC compiler internal procedure index: arctan (real) ]
fpc_in_arctan_real
[fpc_in_assert_x_y |r System:: FPC compiler internal procedure index: assert ]
fpc_in_assert_x_y
[fpc_in_assigned_x |r System:: FPC compiler internal procedure index: assigned ]
fpc_in_assigned_x
[fpc_in_break |r System:: FPC compiler internal procedure index: break ]
fpc_in_break
[fpc_in_chr_byte |r System:: FPC compiler internal procedure index: chr]
fpc_in_chr_byte
[fpc_in_concat_x |r System:: FPC compiler internal procedure index: concat ]
fpc_in_concat_x
[fpc_in_const_abs |r System:: FPC compiler internal procedure index: abs ]
fpc_in_const_abs
[fpc_in_const_arctan |r System:: FPC compiler internal procedure index: arctan ]
fpc_in_const_arctan
[fpc_in_const_cos |r System:: FPC compiler internal procedure index: cos ]
fpc_in_const_cos
[fpc_in_const_exp |r System:: FPC compiler internal procedure index: exp ]
fpc_in_const_exp
[fpc_in_const_frac |r System:: FPC compiler internal procedure index: frac ]
fpc_in_const_frac
[fpc_in_const_int |r System:: FPC compiler internal procedure index: int ]
fpc_in_const_int
[fpc_in_const_ln |r System:: FPC compiler internal procedure index: in ]
fpc_in_const_ln
[fpc_in_const_odd |r System:: FPC compiler internal procedure index: sqr ]
fpc_in_const_odd
[fpc_in_const_pi |r System:: FPC compiler internal procedure index: pi ]
fpc_in_const_pi
[fpc_in_const_ptr |r System:: FPC compiler internal procedure index: sqr ]
fpc_in_const_ptr
[fpc_in_const_round |r System:: FPC compiler internal procedure index: round ]
fpc_in_const_round
[fpc_in_const_sin |r System:: FPC compiler internal procedure index: sin ]
fpc_in_const_sin
[fpc_in_const_sqr |r System:: FPC compiler internal procedure index: sqr ]
fpc_in_const_sqr
[fpc_in_const_sqrt |r System:: FPC compiler internal procedure index: sqrt ]
fpc_in_const_sqrt
[fpc_in_const_swap_long |r System:: FPC compiler internal procedure index: swap (long) ]
fpc_in_const_swap_long
[fpc_in_const_swap_qword |r System:: FPC compiler internal procedure index: swap (qword) ]
fpc_in_const_swap_qword
[fpc_in_const_swap_word |r System:: FPC compiler internal procedure index: swap (word) ]
fpc_in_const_swap_word
[fpc_in_const_trunc |r System:: FPC compiler internal procedure index: trunc ]
fpc_in_const_trunc
[fpc_in_continue |r System:: FPC compiler internal procedure index: continue ]
fpc_in_continue
[fpc_in_copy_x |r System:: FPC compiler internal procedure index: copy ]
fpc_in_copy_x
[fpc_in_cos_real |r System:: FPC compiler internal procedure index: cos (real) ]
fpc_in_cos_real
[fpc_in_cycle |r System:: FPC compiler internal procedure index: cycle ]
fpc_in_cycle
[fpc_in_dec_x |r System:: FPC compiler internal procedure index: dec ]
fpc_in_dec_x
[fpc_in_dispose_x |r System:: FPC compiler internal procedure index: dispose ]
fpc_in_dispose_x
[fpc_in_exclude_x_y |r System:: FPC compiler internal procedure index: exclude ]
fpc_in_exclude_x_y
[fpc_in_exit |r System:: FPC compiler internal procedure index: exit ]
fpc_in_exit
[fpc_in_finalize_x |r System:: FPC compiler internal procedure index: finalize ]
fpc_in_finalize_x
[fpc_in_high_x |r System:: FPC compiler internal procedure index: high ]
fpc_in_high_x
[fpc_in_hi_long |r System:: FPC compiler internal procedure index: hi (long)]
fpc_in_hi_long
[fpc_in_hi_qword |r System:: FPC compiler internal procedure index: hi (qword) ]
fpc_in_hi_qword
[fpc_in_hi_word |r System:: FPC compiler internal procedure index: hi (word)]
fpc_in_hi_word
[fpc_in_include_x_y |r System:: FPC compiler internal procedure index: include ]
fpc_in_include_x_y
[fpc_in_inc_x |r System:: FPC compiler internal procedure index: inc ]
fpc_in_inc_x
[fpc_in_initialize_x |r System:: FPC compiler internal procedure index: initialize ]
fpc_in_initialize_x
[fpc_in_leave |r System:: FPC compiler internal procedure index: leave ]
fpc_in_leave
[fpc_in_length_string |r System:: FPC compiler internal procedure index: length]
fpc_in_length_string
[fpc_in_ln_real |r System:: FPC compiler internal procedure index: ln (real) ]
fpc_in_ln_real
[fpc_in_low_x |r System:: FPC compiler internal procedure index: low ]
fpc_in_low_x
[fpc_in_lo_long |r System:: FPC compiler internal procedure index: lo (long)]
fpc_in_lo_long
[fpc_in_lo_qword |r System:: FPC compiler internal procedure index: lo (qword) ]
fpc_in_lo_qword
[fpc_in_lo_word |r System:: FPC compiler internal procedure index: lo (word)]
fpc_in_lo_word
[fpc_in_mmx_pcmpeqb |r System:: FPC compiler internal procedure index: MMX ]
fpc_in_mmx_pcmpeqb
[fpc_in_mmx_pcmpeqd |r System:: FPC compiler internal procedure index: MMX ]
fpc_in_mmx_pcmpeqd
[fpc_in_mmx_pcmpeqw |r System:: FPC compiler internal procedure index: MMX ]
fpc_in_mmx_pcmpeqw
[fpc_in_mmx_pcmpgtb |r System:: FPC compiler internal procedure index: MMX ]
fpc_in_mmx_pcmpgtb
[fpc_in_mmx_pcmpgtd |r System:: FPC compiler internal procedure index: MMX ]
fpc_in_mmx_pcmpgtd
[fpc_in_mmx_pcmpgtw |r System:: FPC compiler internal procedure index: MMX ]
fpc_in_mmx_pcmpgtw
[fpc_in_new_x |r System:: FPC compiler internal procedure index: new ]
fpc_in_new_x
[fpc_in_ofs_x |r System:: FPC compiler internal procedure index: ofs ]
fpc_in_ofs_x
[fpc_in_ord_x |r System:: FPC compiler internal procedure index: ord ]
fpc_in_ord_x
[fpc_in_pi |r System:: FPC compiler internal procedure index: pi ]
fpc_in_pi
[fpc_in_pred_x |r System:: FPC compiler internal procedure index: pred ]
fpc_in_pred_x
[fpc_in_prefetch_var |r System:: FPC compiler internal procedure index: prefetch ]
fpc_in_prefetch_var
[fpc_in_readln_x |r System:: FPC compiler internal procedure index: readln]
fpc_in_readln_x
[fpc_in_read_x |r System:: FPC compiler internal procedure index: read]
fpc_in_read_x
[fpc_in_reset_typedfile |r System:: FPC compiler internal procedure index: reset ]
fpc_in_reset_typedfile
[fpc_in_reset_x |r System:: FPC compiler internal procedure index: reset ]
fpc_in_reset_x
[fpc_in_rewrite_typedfile |r System:: FPC compiler internal procedure index: rewrite ]
fpc_in_rewrite_typedfile
[fpc_in_rewrite_x |r System:: FPC compiler internal procedure index: rewrite ]
fpc_in_rewrite_x
[fpc_in_seg_x |r System:: FPC compiler internal procedure index: seg ]
fpc_in_seg_x
[fpc_in_setlength_x |r System:: FPC compiler internal procedure index: setlength ]
fpc_in_setlength_x
[fpc_in_settextbuf_file_x |r System:: FPC compiler internal procedure index: settextbuf ]
fpc_in_settextbuf_file_x
[fpc_in_sin_real |r System:: FPC compiler internal procedure index: sin (real) ]
fpc_in_sin_real
[fpc_in_sizeof_x |r System:: FPC compiler internal procedure index: sizeof ]
fpc_in_sizeof_x
[fpc_in_sqrt_real |r System:: FPC compiler internal procedure index: sqrt (real) ]
fpc_in_sqrt_real
[fpc_in_sqr_real |r System:: FPC compiler internal procedure index: sqr (real) ]
fpc_in_sqr_real
[fpc_in_str_x_string |r System:: FPC compiler internal procedure index: str ]
fpc_in_str_x_string
[fpc_in_succ_x |r System:: FPC compiler internal procedure index: succ ]
fpc_in_succ_x
[fpc_in_typeinfo_x |r System:: FPC compiler internal procedure index: typeinfo ]
fpc_in_typeinfo_x
[fpc_in_typeof_x |r System:: FPC compiler internal procedure index: typeof ]
fpc_in_typeof_x
[fpc_in_val_x |r System:: FPC compiler internal procedure index: val ]
fpc_in_val_x
[fpc_in_writeln_x |r System:: FPC compiler internal procedure index: writeln]
fpc_in_writeln_x
[fpc_in_write_x |r System:: FPC compiler internal procedure index: write]
fpc_in_write_x
[GrowHeapSize1 |r System:: Grow rate for block less than 256 Kb.]
GrowHeapSize1
[GrowHeapSize2 |r System:: Grow rate for block larger than 256 Kb.]
GrowHeapSize2
[GrowHeapSizeSmall |r System:: Fixed size small blocks grow rate]
GrowHeapSizeSmall
[InitProc |r System:: Initialization routine]
InitProc
[IsMultiThread |r System:: Indicates whether more than one thread is running in the application.]
IsMultiThread
[LFNSupport |r System:: COnstant describing support for long filenames.]
LFNSupport
[LineEnding |r System:: Constant describing the current line ending character.]
LineEnding
[MaxExitCode |r System:: Maximum exit code supported by the operating system.]
MaxExitCode
[Maxint |r System:: Maximum integer value.]
Maxint
[MaxLongint |r System:: Maximum longint value.]
MaxLongint
[MaxPathLen]
MaxPathLen
[MaxSIntValue |r System:: Maximum String-size value.]
MaxSIntValue
[MaxSmallint |r System:: Maximum smallint value.]
MaxSmallint
[MaxUIntValue |r System:: Maximum unsigned integer value.]
MaxUIntValue
[Max_Frame_Dump |r System:: Maximum number of frames to show in error frame dump.]
Max_Frame_Dump
[PathSeparator |r System:: Character used to separate paths in a search list]
PathSeparator
[RaiseMaxFrameCount |r System:: Maximum number of frames to include in TExceptObject]
RaiseMaxFrameCount
[RaiseProc |r System:: Procedure to raise an exception.]
RaiseProc
[SLineBreak |r System:: Alias for LineEnding]
SLineBreak
[StackError |r System:: Indicate whether there was a stack error.]
StackError
[StdErrorHandle |r System:: Value of the OS handle for the standard error-output file.]
StdErrorHandle
[StdInputHandle |r System:: Value of the OS handle for the standard input file.]
StdInputHandle
[StdOutputHandle |r System:: Value of the OS handle for the standard output file.]
StdOutputHandle
[s_false |r System:: Interface call result: Not OK]
s_false
[s_ok |r System:: Interface call result: OK]
s_ok
[ThreadingAlreadyUsed |r System:: Internal constant for the threading system. Don't use.]
ThreadingAlreadyUsed
[UnusedHandle |r System:: Value indicating an unused file handle (as reported by the OS).]
UnusedHandle
[VarAddRefProc |r System:: Callback to increase reference count of a variant.]
VarAddRefProc
[VarAny |r System:: Variant type: Any ]
VarAny
[VarArray |r System:: Variant type: variant Array ]
VarArray
[VarBoolean |r System:: Variant type: Boolean type ]
VarBoolean
[VarByref |r System:: Variant type: By reference ]
VarByref
[VarByte |r System:: Variant type: Byte (8 bit) ]
VarByte
[VarClearProc |r System:: Callback to clear a variant.]
VarClearProc
[VarCopyProc |r System:: Callback to copy a variant]
VarCopyProc
[VarCurrency |r System:: Variant type: Currency ]
VarCurrency
[VarDate |r System:: Variant type: Date ]
VarDate
[VarDecimal |r System:: Variant type: Decimal (BCD) ]
VarDecimal
[VarDispatch |r System:: Variant type: dispatch interface ]
VarDispatch
[VarDouble |r System:: Variant type: Double float ]
VarDouble
[VarEmpty |r System:: Variant type: Empty variant]
VarEmpty
[VarError |r System:: Variant type: Error type ]
VarError
[VarInt64 |r System:: Variant type: Integer (64-Bit) ]
VarInt64
[VarInteger |r System:: Variant type: Integer (32-bit)]
VarInteger
[VarLongword |r System:: Variant type: Word (32 bit) ]
VarLongword
[VarNull |r System:: Variant type: Null variant ]
VarNull
[VarOLEStr |r System:: Variant type: OLE string (widestring) ]
VarOLEStr
[VarQword |r System:: Variant type: Word (64-bit) ]
VarQword
[VarShortint |r System:: Variant type: Shortint (16 bit) ]
VarShortint
[VarSingle |r System:: Variant type: Single float ]
VarSingle
[VarSmallint |r System:: Variant type: smallint (8 bit) ]
VarSmallint
[VarStrarg |r System:: Variant type: String ]
VarStrarg
[VarString |r System:: Variant type: String ]
VarString
[VarToLStrProc |r System:: Callback to convert a variant to a ansistring.]
VarToLStrProc
[VarToWStrProc |r System:: Callback to convert a variant to a widestring.]
VarToWStrProc
[VarTypeMask |r System:: Variant type: Mask to extract type ]
VarTypeMask
[VarUnknown |r System:: Variant type: Unknown ]
VarUnknown
[VarVariant |r System:: Variant type: Variant (arrays only) ]
VarVariant
[VarWord |r System:: Variant type: Word (16 bit) ]
VarWord
[VarWord64 |r System:: Variant type: Word (64-bit) ]
VarWord64
[vmtAfterConstruction |r System:: VMT Layout: ?]
vmtAfterConstruction
[vmtAutoTable |r System:: VMT layout: ?]
vmtAutoTable
[vmtBeforeDestruction |r System:: VMT Layout: ?]
vmtBeforeDestruction
[vmtClassName |r System:: VMT Layout: location of class name.]
vmtClassName
[vmtDefaultHandler |r System:: VMT Layout: ?]
vmtDefaultHandler
[vmtDefaultHandlerStr |r System:: VMT Layout: ?]
vmtDefaultHandlerStr
[vmtDestroy |r System:: VMT Layout: Location of destructor pointer.]
vmtDestroy
[vmtDynamicTable |r System:: VMT Layout: location of dynamic methods table.]
vmtDynamicTable
[vmtFieldTable |r System:: VMT Layout: Location of fields table.]
vmtFieldTable
[vmtFreeInstance |r System:: VMT Layout: location of FreeInstance method.]
vmtFreeInstance
[vmtInitTable |r System:: VMT Layout: ?]
vmtInitTable
[vmtInstanceSize |r System:: VMT Layout: Location of class instance size in VMT]
vmtInstanceSize
[vmtIntfTable |r System:: VMT layout: Interface table]
vmtIntfTable
[vmtMethodStart |r System:: VMT layout: start of method table.]
vmtMethodStart
[vmtMethodTable |r System:: VMT Layout: Method table start.]
vmtMethodTable
[vmtMsgStrPtr |r System:: VMT layout: message strings table.]
vmtMsgStrPtr
[vmtNewInstance |r System:: VMT Layout: location of NewInstance method.]
vmtNewInstance
[vmtParent |r System:: VMT Layout: location of pointer to parent VMT.]
vmtParent
[vmtSafeCallException |r System:: VMT Layout: ?]
vmtSafeCallException
[vmtTypeInfo |r System:: VMT Layout: Location of class type information.]
vmtTypeInfo
[vtAnsiString |r System:: TVarRec type: Ansistring]
vtAnsiString
[vtBoolean |r System:: TVarRec type: Boolean]
vtBoolean
[vtChar |r System:: TVarRec type: Char]
vtChar
[vtClass |r System:: TVarRec type: Class type]
vtClass
[vtCurrency |r System:: TVarRec type: Currency]
vtCurrency
[vtExtended |r System:: TVarRec type: Extended]
vtExtended
[vtInt64 |r System:: TVarRec type: Int64 (signed 64-bit integer)]
vtInt64
[vtInteger |r System:: TVarRec type: Integer]
vtInteger
[vtInterface |r System:: TVarRec type: Interface]
vtInterface
[vtObject |r System:: TVarRec type: Object instance]
vtObject
[vtPChar |r System:: TVarRec type: PChar]
vtPChar
[vtPointer |r System:: TVarRec type: pointer]
vtPointer
[vtPWideChar |r System:: TVarRec type: PWideChar]
vtPWideChar
[vtQWord |r System:: TVarRec type: QWord (unsigned 64-bit integer)]
vtQWord
[vtString |r System:: TVarRec type: String]
vtString
[vtVariant |r System:: TVarRec type: Variant]
vtVariant
[vtWideChar |r System:: TVarRec type: Widechar]
vtWideChar
[vtWideString |r System:: TVarRec type: WideString]
vtWideString


[AnsiChar |p System:: Alias for 1-byte sized char.]
AnsiChar
[Byte |p System:: An unsigned 8-bits integer]
Byte
[Cardinal |p System:: An unsigned 32-bits integer.]
Cardinal
[Currency |p System:: Currency type.]
Currency
[DWord |p System:: An unsigned 32-bits integer]
DWord
[Error |p System:: 32-bit signed integer.]
Error
[HResult |p System:: 32-Bit signed integer.]
HResult
[Integer |p System:: A signed 16-bits integer]
Integer
[IntegerArray |p System:: Generic array of integer. ]
IntegerArray
[jmp_buf |p System:: Record type to store processor information.]
jmp_buf
[Longint |p System:: A signed 32-bits integer]
Longint
[PAnsiChar |p System:: Alias for PChar type.]
PAnsiChar
[PAnsiString |p System:: Pointer to an ansistring type.]
PAnsiString
[PBoolean |p System:: Pointer to a Boolean type.]
PBoolean
[PByte |p System:: Pointer to byte type]
PByte
[PCallDesc |p System:: Pointer to TCallDesc record.]
PCallDesc
[PCardinal |p System:: Pointer to Cardinal type]
PCardinal
[PChar |p System:: Pointer to null-terminated string.]
PChar
[PClass |p System:: Pointer to TClass]
PClass
[PCurrency |p System:: Pointer to currency type.]
PCurrency
[PDate |p System:: Pointer to a TDateTime type.]
PDate
[PDispDesc |p System:: Pointer to tdispdesc record]
PDispDesc
[PDouble |p System:: Pointer to double-sized float value.]
PDouble
[PDWord |p System:: Pointer to DWord type]
PDWord
[PDynArrayIndex |p System:: Pointer to tdynarrayindex type.]
PDynArrayIndex
[PError |p System:: Pointer to an Error type.]
PError
[PEventState |p System:: Pointer to EventState, which is an opaque type.]
PEventState
[PExceptObject |p System:: Pointer to Exception handler procedural type TExceptProc]
PExceptObject
[PExtended |p System:: Pointer to extended-sized float value.]
PExtended
[PGuid |p System:: Pointer to TGUID type. ]
PGuid
[PInt64 |p System:: Pointer to Int64 type]
PInt64
[PInteger |p System:: Pointer to integer type]
PInteger
[PIntegerArray |p System:: Pointer to IntegerArray type]
PIntegerArray
[PInterfaceEntry |p System:: Pointer to tinterfaceentry record.]
PInterfaceEntry
[PInterfaceTable |p System:: Pointer to tinterfacetable record.]
PInterfaceTable
[PJmp_buf |p System:: Pointer to jmp_buf record]
PJmp_buf
[PLongBool |p System:: Pointer to a LongBool type.]
PLongBool
[PLongint |p System:: Pointer to Longint type]
PLongint
[PLongWord |p System:: Pointer to LongWord type]
PLongWord
[PMemoryManager |p System:: Pointer to TMemoryManager record]
PMemoryManager
[PMsgStrTable |p System:: Pointer to array of TMsgStrTable records.]
PMsgStrTable
[PointerArray |p System:: Generic pointer array.]
PointerArray
[POleVariant |p System:: Pointer to OleVariant type.]
POleVariant
[PPAnsiChar |p System:: Alias for PPChar type.]
PPAnsiChar
[PPChar |p System:: Pointer to an array of pointers to null-terminated strings.]
PPChar
[PPCharArray |p System:: Pointer to TPCharArray type.]
PPCharArray
[PPointer |p System:: Pointer to a pointer type.]
PPointer
[PPointerArray |p System:: Pointer to PointerArray type]
PPointerArray
[PPPointer |p System:: Pointer to a PPointer type.]
PPPointer
[PPtrInt |p System:: Pointer to PtrInt type.]
PPtrInt
[PPWideChar |p System:: Pointer to link id="PWideChar"> type.]
PPWideChar
[PQWord |p System:: Pointer to QWord type]
PQWord
[PRTLCriticalSection |p System:: Pointer to #rtl.system.TRTLCriticalSection type.]
PRTLCriticalSection
[PRTLEvent |p System:: Pointer to RTLEvent, which is an opaque type.]
PRTLEvent
[PShortInt |p System:: Pointer to shortint type]
PShortInt
[PShortString |p System:: Pointer to a shortstring type.]
PShortString
[PSingle |p System:: Pointer to single-sized float value.]
PSingle
[PSizeInt |p System:: Pointer to a SizeInt type]
PSizeInt
[PSmallInt |p System:: Pointer to smallint type]
PSmallInt
[PStringMessageTable |p System:: Pointer to TStringMessageTable record.]
PStringMessageTable
[PText |p System:: Pointer to text file.]
PText
[PtrInt |p System:: Signed integer type with same size as Pointer.]
PtrInt
[PtrUInt |p System:: Unsigned integer type with same size as Pointer.]
PtrUInt
[PUCS2Char |p System:: Pointer to UCS2Char character.]
PUCS2Char
[PUCS4Char |p System:: Pointer to UCS4Char]
PUCS4Char
[PUCS4CharArray |p System:: Pointer to array of UCS4Char characters.]
PUCS4CharArray
[PUTF8String |p System:: Pointer to UTF8String]
PUTF8String
[PVarArray |p System:: Pointer to TVarArray type.]
PVarArray
[PVarArrayBound |p System:: Pointer to tvararraybound type.]
PVarArrayBound
[PVarArrayBoundArray |p System:: Pointer to tvararrayboundarray type.]
PVarArrayBoundArray
[PVarArrayCoorArray |p System:: Pointer to tvararraycoorarray type.]
PVarArrayCoorArray
[PVarData |p System:: Pointer to TVarData record.]
PVarData
[PVariant |p System:: Pointer to Variant type.]
PVariant
[PVariantManager |p System:: Pointer to TVariantManager record.]
PVariantManager
[PVarRec |p System:: Pointer to TVarRec type.]
PVarRec
[PWideChar |p System:: Pointer to WChar.]
PWideChar
[PWord |p System:: Pointer to word type]
PWord
[PWordBool |p System:: Pointer to a WordBool type.]
PWordBool
[Real48 |p System:: TP compatible real type (6 bytes) definition]
Real48
[ShortInt |p System:: A signed 8-bits integer]
ShortInt
[SizeInt |p System:: Signed integer type which fits for sizes]
SizeInt
[SizeUInt |p System:: Unsigned Integer type which fits for sizes]
SizeUInt
[SmallInt |p System:: A signed 16-bits integer]
SmallInt
[TAbstractErrorProc |p System:: Abstract error handler procedural type.]
TAbstractErrorProc
[TAllocateThreadVarsHandler |p System:: Threadvar allocation callback type for TThreadManager.]
TAllocateThreadVarsHandler
[TAnsiChar |p System:: Alias for 1-byte sized char.]
TAnsiChar
[TAssertErrorProc |p System:: Assert error handler procedural type.]
TAssertErrorProc
[TBackTraceStrFunc |p System:: Type for formatting of backtrace dump.]
TBackTraceStrFunc
[TBasicEventCreateHandler |p System:: callback type for creating eventstate in TThreadManager.]
TBasicEventCreateHandler
[TBasicEventHandler |p System:: Generic callback type for handling eventstate in TThreadManager.]
TBasicEventHandler
[TBasicEventWaitForHandler |p System:: Wait for basic event callback type for TThreadManager.]
TBasicEventWaitForHandler
[TBeginThreadHandler |p System:: Callback for thread start in TThreadManager.]
TBeginThreadHandler
[TBoundArray |p System:: Dynamic array of integer.]
TBoundArray
[TCallDesc |p System:: COM/OLE dispatch call argument description.]
TCallDesc
[TClass |p System:: Class of TObject.]
TClass
[TCriticalSectionHandler |p System:: Generic callback type for critical section handling in TThreadManager.]
TCriticalSectionHandler
[TDateTime |p System:: Encoded Date-Time type.]
TDateTime
[TDispDesc |p System:: COM/OLE dispatch call description.]
TDispDesc
[TDynArrayIndex |p System:: Type with the correct size for index into a dynamic array.]
TDynArrayIndex
[TEndThreadHandler |p System:: Callback for thread end in TThreadManager.]
TEndThreadHandler
[TErrorProc |p System:: Standard error handler procedural type.]
TErrorProc
[TExceptObject |p System:: Exception object]
TExceptObject
[TExceptProc |p System:: Exception handler procedural type]
TExceptProc
[TextFile |p System:: Alias for Text file type.]
TextFile
[TGetCurrentThreadIdHandler |p System:: Callback type for retrieving thread ID in TThreadManager.]
TGetCurrentThreadIdHandler
[TGuid |p System:: Standard GUID representation type.]
TGuid
[THandle |p System:: Type alias.]
THandle
[THeapStatus |p System:: Record describing current heap status.]
THeapStatus
[TInitThreadVarHandler |p System:: Threadvar initialization callback type for TThreadManager.]
TInitThreadVarHandler
[TInterfaceEntry |p System:: Interfaces table entry.]
TInterfaceEntry
[TInterfaceTable |p System:: Record to store list of interfaces of a class.]
TInterfaceTable
[TMemoryManager |p System:: Record describing the current memory manager]
TMemoryManager
[TMemoryMutexManager |p System:: Record describing the mutex manager for the heap.]
TMemoryMutexManager
[TMethod |p System:: Record describing a method.]
TMethod
[TMsgStrTable |p System:: Record used in string message handler table.]
TMsgStrTable
[TPCharArray |p System:: Array of PChar]
TPCharArray
[TProcedure |p System:: Simple procedural type.]
TProcedure
[TReleaseThreadVarsHandler |p System:: Threadvar release callback type for TThreadManager.]
TReleaseThreadVarsHandler
[TRelocateThreadVarHandler |p System:: Threadvar relocalization callback type for TThreadManager.]
TRelocateThreadVarHandler
[TRTLCreateEventHandler |p System:: Callback type for creating a TRTLEvent type in TThreadManager.]
TRTLCreateEventHandler
[TRTLCriticalSection |p System:: A critical section.]
TRTLCriticalSection
[TRTLEventHandler |p System:: Generic TRTLEvent handling type for TThreadManager.]
TRTLEventHandler
[TRTLEventHandlerTimeout |p System:: TRTLEvent timeout handling type for TThreadManager.]
TRTLEventHandlerTimeout
[TRTLEventSyncHandler |p System:: Callback type for event sycnhronization in TThreadManager.]
TRTLEventSyncHandler
[TRtlMethod |p System:: Callback type for synchronization event.]
TRtlMethod
[TStringMessageTable |p System:: String message table container for class.]
TStringMessageTable
[TTextLineBreakStyle |p System:: Text line break style. (end of line character)]
TTextLineBreakStyle
[TThreadFunc |p System:: Thread function prototype]
TThreadFunc
[TThreadGetPriorityHandler |p System:: Callback type for thread priority getting in TThreadManager.]
TThreadGetPriorityHandler
[TThreadHandler |p System:: Generic thread handler callback for TThreadManager.]
TThreadHandler
[TThreadID |p System:: Type for Thread-IDs]
TThreadID
[TThreadManager |p System:: Thread manager record.]
TThreadManager
[TThreadSetPriorityHandler |p System:: Callback type for thread priority setting in TThreadManager.]
TThreadSetPriorityHandler
[TThreadSwitchHandler |p System:: Callback type for thread switch in TThreadManager.]
TThreadSwitchHandler
[TUCS4CharArray |p System:: Array of UCS4Char characters.]
TUCS4CharArray
[TVarArray |p System:: Type describing variant array]
TVarArray
[TVarArrayBound |p System:: Type describing variant array bounds.]
TVarArrayBound
[TVarArrayBoundArray |p System:: array of tvararraybound records.]
TVarArrayBoundArray
[TVarArrayCoorArray |p System:: Array of variant array coordinates]
TVarArrayCoorArray
[TVarData |p System:: Variant record.]
TVarData
[TVariantManager |p System:: Record describing the variant manager.]
TVariantManager
[TVarOp |p System:: Variant operation.]
TVarOp
[TVarRec |p System:: Record describing an element in an array of const]
TVarRec
[TVarType |p System:: Type with size of variant type.]
TVarType
[TWaitForThreadTerminateHandler |p System:: Callback type for thread termination in TThreadManager.]
TWaitForThreadTerminateHandler
[UCS2Char |p System:: UCS2 unicode character.]
UCS2Char
[UCS4Char |p System:: UCS unicode character (unsigned 32 bit word)]
UCS4Char
[UCS4String |p System:: String of UCS4Char characters.]
UCS4String
[UTF8String |p System:: UTF-8 unicode (ansi) string.]
UTF8String
[ValSInt |p System:: Val-Signed integer.]
ValSInt
[ValUInt |p System:: Val-unsigned integer]
ValUInt
[WChar |p System:: Wide char (16-bit sized char)]
WChar
[Word |p System:: An unsigned 16-bits integer]
Word

[TObject |g System:: Base class of all classes.]
TObject

[Abs |b System:: Calculate absolute value (Longint|Int64|ValReal)]
Abs(§|) {? value: Longint|Int64|ValReal}
[AbstractError |b System:: Generate an abstract error.]
AbstractError
[AcquireExceptionObject |b System:: Obtain a reference to the current exception object (Pointer)]
AcquireExceptionObject
[AddExitProc |b System:: Add an exit procedure to the exit procedure chain.]
AddExitProc(§|) {? proc: TProcedure}
[Addr |b System:: Return address of a variable (Pointer)]
Addr(§|)
[Align |b System:: Return aligned version of an address (PtrInt|Pointer)]
Align(§|,) {? addr: PtrInt|Pointer; alignment: PtrInt}
[AllocMem |b System:: Alias for GetMem (Pointer)]
AllocMem(§|) {? size: PtrInt}
[Append |b System:: Open a file in append mode]
Append(§|) {? var t: Text}
[ArcTan |b System:: Calculate inverse tangent (ValReal)]
ArcTan(§|) {? value: ValReal}
[ArrayStringToPPchar |b System:: Concert an array of string to an array of null-terminated strings]
ArrayStringToPPchar(§|,); {? const S: array [] of AnsiString; reserveentries: LongInt}
[AsmFreemem |b System:: Routine that can be called from assembler routines to release memory.]
AsmFreemem(§|) {? p: Pointer}
[AsmGetmem |b System:: Routine that can be called from assembler routines to get memory.]
AsmGetmem(§|,) {? var p: Pointer; size: PtrInt}
[Assert |b System:: Check validity of a given condition.]
Assert(§|,) {? expr: Boolean; optional const msg: String}
[Assign |b System:: Assign a name to a file]
Assign(§|,) {? var f: File|TypedFile|Text; const name: String|Pchar|Char}
[Assigned |b System:: Check if a pointer is valid (boolean)]
Assigned(§|) {? P: Pointer}
[BasicEventCreate |b System:: Obsolete. Don't use (PEventState)]
BasicEventCreate(§|,,,) {? EventAttributes: Pointer; AManualReset: Boolean; InitialState: Boolean; const Name: Ansistring}
[BasicEventDdestroy |b System:: Obsolete. Don't use]
BasicEventDestroy(§|) {? state: PEventState}
[BasicEventResetEvent |b System:: Obsolete. Don't use]
BasicEventResetEvent(§|) {? state: PEventState}
[BasicEventSetEvent |b System:: Obsolete. Don't use]
BasicEventSetEvent(§|) {? state: PEventState}
[BasicEventWaitFor |b System:: Obsolete. Don't use (LongInt)]
BasicEventWaitFor(§|) {? Timeout: Cardinal;state: PEventState}
[BeginThread |b System:: Start a new thread. (DWord)]
BeginThread(§|,,,,,) {? sa: Pointer; stacksize: DWord; ThreadFunction: TThreadFunc; p: pointer; creationFlags: DWord; var ThreadId: TThreadID}
[BinStr |b System:: Convert integer to string with binary representation (ShortString)]
BinStr(§|,) {? Val: LongInt|Int64; cnt: Byte}
[BlockRead |b System:: Read data from an untyped file into memory]
BlockRead(§|,,,) {? var f: File; var Buf; count: LongInt|Word|Cardinal; optional var Result: LongInt|Word|Cardinal}
[BlockWrite |b System:: Write data from memory to an untyped file]
BlockWrite(§|,,,) {? var f: File; const Buf; Count: LongInt|Word|Cardinal; optional var Result: LongInt|Word|Cardinal}
[Break |b System:: Exit current loop construct.]
Break
[ChDdir |b System:: Change current working directory.]
ChDir(§|) {? const s: String}
[Chr |b System:: Convert byte value to character value (Char)]
Chr(§|) {? b: Byte}
[Close |b System:: Close a file]
Close(§|) {? var f: File|Text}
[CompareByte |b System:: Compare 2 memory buffers byte per byte (SizeInt)]
CompareByte(§|,,) {? const buf1; const buf2; len: SizeInt}
[CompareChar |b System:: ompare 2 memory buffers character per character]
CompareChar(§|,,) {? const buf1; const buf2; len: SizeInt}
[CompareChar0 |b System:: Compare two buffers character by character till a null-character is reached (SizeInt)]
CompareChar0(§|,,) {? const buf1; const buf2; len: SizeInt}
[CompareDWord |b System:: Compare 2 memory buffers DWord per DWord (SizeInt)]
CompareDWord(§|,,) {? const buf1; const buf2; len: SizeInt}
[CompareWord |b System:: Compare 2 memory buffers word per word (SizeInt)]
CompareWord(§|,,) {? const buf1; const buf2; len: SizeInt}
[Concat |b System:: Append one string to another (String)]
Concat(§|,) {? const S1: String; const S2: String; const S3: String; const Sn: String} 
[Continue |b System:: Continue with next loop cycle.]
Continue
[Copy |b System:: Copy part of a string.(Shortstring|AnsiString)]
Copy(§|,,) {? const s: Shortstring|AnsiString|Char; index: SizeInt; count: SizeInt}
[Cos |b System:: Calculate cosine of angle (ValReal)]
Cos(§|) {? d: ValReal} 
[Cseg |b System:: Return code segment (Word)]
Cseg
[Dec |b System:: Decrease value of variable]
Dec(§|,) {? var X: TOrdinal; optional Decrement: TOrdinal}
[Delete |b System:: Delete part of a string.]
Delete(§|,,) {? var S: ShortString|AnsiString; Index: SizeInt; Count: SizeInt}
[Dispose |b System:: Free dynamically allocated memory]
Dispose(§|,) {? P: TypedPointer; Des: TProcedure}
[DoneCriticalsection |b System:: Clean up a critical section.]
DoneCriticalsection(§|) {? var cs: TRTLCriticalSection}
[Dseg |b System:: Return data segment (Word)]
Dseg 
[Dump_Stack |b System:: Dump stack to the given text file.]
Dump_Stack(§|,) {? var f: text; bp: pointer}
[EndThread |b System:: End the current thread.]
EndThread(§|) {? optional ExitCode: DWord}
[EnterCriticalSection |b System:: Enter a critical section]
EnterCriticalsection(var cs: TRTLCriticalSection}
[EOF |b System:: Check for end of file (Boolean)]
EOF(§|) {? optional var f: File|Text} 
[EOLn |b System:: Check for end of line (Boolean)]
EOLn(§|) {? optional var t: File|Text}
[Erase |b System:: Delete a file from disk]
Erase(§|) {? var f: File|Text}
[Exclude |b System:: Exlude element from a set if it is present.]
Exclude(§|,) {? var S: TSetType; E: TSetElement}
[Exit |b System:: Exit current subroutine.]
Exit(§|) {? optional const X: TAnyType}
[Exp |b System:: Exponentiate (ValReal)]
Exp(§|) {? d: ValReal}
[FilePos |b System:: Get position in file (LongInt)]
FilePos(§|) {? var f: File}
[FileSize |b System:: Size of file (LongInt)]
FileSize(§|) {? var f: File}
[FillByte |b System:: Fill memory region with 8-bit pattern]
FillByte(§|,,) {? var x; count: SizeInt; value: Byte}
[FillChar |b System:: Fill memory region with certain character]
FillChar(§|,,) {? var x; count: SizeInt; value: Boolean|Char|Byte}
[FillDWord |b System:: Fill memory region with 32-bit pattern]
FillDWord(§|,,) {? var x; count: SizeInt; value: DWord}
[FillWord |b System:: Fill memory region with 16-bit pattern]
FillWord(§|,,) {? var x; count: SizeInt; value: Word}
[Flush |b System:: Write file buffers to disk]
Flush(§|) {? var t: Text};
[Frac |b System:: Return fractional part of floating point value (ValReal)]
Frac(§|) {? d: ValReal}
[Freemem |b System:: Release allocated memory (PtrInt)]
Freemem(§|) {? p: pointer}
[Freememory |b System:: Alias for FreeMem (PtrInt)]
Freememory(§|) {? p: pointer}
[GetCurrentThreadId |b System:: Return the id of the currently running thread (TThreadID)]
GetCurrentThreadId
[GetDir |b System:: Return the current directory]
Getdir(§|) {? drivenr: Byte; var dir: Shortstring|AnsiString)
[GetHeapStatus |b System:: Return the memory manager heap status.]
GetHeapStatus(§|) {? var status: THeapStatus)
[GetMem |b System:: Allocate new memory on the heap (Pointer)]
GetMem(§|) {? size: PtrInt}
[GetMemory |b System:: Alias for GetMem (Pointer)]
GetMemory(§|) {? size: PtrInt} 
[GetMemoryManager |b System:: Return current memory manager]
GetMemoryManager(§|) {? var MemMgr: TMemoryManager}
[GetProcessID |b System:: Get the current process ID (SizeUInt)]
GetProcessID
[GetThreadID |b System:: Get the current Thread ID (SizeUInt)]
GetThreadID
[GetThreadManager |b System:: Return the current thread manager (Boolean)]
GetThreadManager(§|) {? var TM: TThreadManager} 
[GetVariantManager |b System:: Return the current variant manager.]
GetVariantManager(§|) {? var VarMgr: tvariantmanager}
[get_caller_addr |b System:: Return the address of the caller (Pointer)]
get_caller_addr(§|) {? framebp: pointer} 
[get_caller_frame |b System:: Return the frame pointer of the caller (Pointer)]
get_caller_frame(§|) {? framebp: pointer}
[get_frame |b System:: Return the current frame (Pointer)]
get_frame
[Halt |b System:: Stop program execution.]
Halt(§|) {? optional errnum: Byte}
[HexStr |b System:: Convert integer value to string with hexadecimal representation (Shortstring)]
HexStr(§|,) {? Val: LongInt|Int64|Pointer; optional cnt: Byte} 
[Hi |b System:: Return high byte/word of value (Byte|Word|Dword)]
Hi(§|) {? b: Byte|Integer|Word|LongInt|QWord|Int64} 
[High |b System:: Return highest index of open array or enumerated (TOrdinal)]
High(§|) {? Arg: TypeOrVariable}
[Inc |b System:: Increase value of integer variable]
Inc(§|,) {? var X: TOrdinal; optional Increment: TOrdinal}
[Include |b System:: Include element in set if it was not yet present.]
Include(§|,) {? var S: TSetType; E: TSetElement}
[IndexByte |b System:: Search for a byte in a memory range (SizeInt)]
IndexByte(§|,,) {? const buf; len: SizeInt; b: Byte}
[IndexChar |b System:: Search for a character in a memory range (SizeInt)]
IndexChar(§|,,) {? const buf; len: SizeInt; b: Char}
[IndexChar0 |b System:: Return index of a character in null-terminated array of char (SizeInt)]
IndexChar0(§|,,) {? const buf; len: SizeInt; b: Char}
[IndexDWord |b System:: Search for a DWord value in a memory range (SizeInt)]
IndexDWord(§|,,) {? const buf; len: SizeInt; b: DWord}
[Indexword |b System:: Search for a WORD value in a memory range.]
Indexword(§|,,) {? const buf; len: SizeInt; b: Word}
[InitCriticalSection |b System:: Initialize a critical section]
InitCriticalSection(§|) {? var cs: TRTLCriticalSection}
[InitThread |b System:: Initialize a thread]
InitCriticalSection(§|) {? var cs: TRTLCriticalSection}
[Insert |b System:: Insert one string in another.]
Insert(§|,,) {? const source: Shortstring|Char|AnsiString; var s: shortstring|AnsiString; index: SizeInt}
[Int |b System:: Calcuate integer part of floating point value (ValReal)]
Int(§|) {? d: ValReal}
[IOResult |b System:: Return result of last file IO operation (Word)]
IOResult
[IsMemoryManagerSet |b System:: Is the memory manager set (Boolean)]
IsMemoryManagerSet
[IsVariantManagerSet |b System:: Determine if variant manager is currently set (Boolean)]
IsVariantManagerSet
[KillThread |b System:: Kill a running thread (DWord)]
KillThread(§|) {? threadHandle: TThreadID}
[LeaveCriticalsection |b System:: Leave a critical section]
LeaveCriticalsection(§|) {? var cs: TRTLCriticalSection}
[Length |b System:: Calculate length of a string (Byte)]
Length(§|) {? s: String|Char|AnsiString}
[Ln |b System:: Calculate logarithm (ValReal)]
Ln(§|) {? d: ValReal} 
[Lo |b System:: Return low byte/word of value (Byte|Word|DWord)]
Lo(§|) {? B: Byte|Integer|Word|Longint|Dword|Int64|QWord)
[LongJmp |b System:: Jump to address.]
LongJmp(§|,) {? var S: jmp_buf; value: LongInt}
[Low |b System:: Return lowest index of open array or enumerated (TOrdinal)]
Low(§|) {? Arg: TypeOrVariable}
[LowerCase |b System:: Return lowercase version of a string (Shortstring|Char|Ansistring)]
LowerCase(§|) {? const s: Shortstring|Char|Ansistring)
[MemSize |b System:: Return the size of a memory block (PtrInt)]
MemSize(§|) {? p: pointer}
[MkDir |b System:: Create a new directory.]
MkDir(§|) {? const s: String}
[Move |b System:: Move data from one location in memory to another]
Move(§|,,) {? const source; var dest; count: SizeInt}
[MoveChar0 |b System:: Move data till first zero character]
MoveChar0(§|,) {? const buf1; var buf2; len: SizeInt}
[New |b System:: Dynamically allocate memory for variable]
New(§|,) {? var P: Pointer; optional Cons: TProcedure}
[OctStr |b System:: Convert integer to a string with octal representation {Shortstring}]
OctStr(§|,) {? Val: LongInt|Int64; cnt: Byte}
[Odd |b System:: Is a value odd or even (Boolean)]
Odd(§|) {? l: LongInt|LongWord|Int64|QWord}
[Ofs |b System:: Return offset of a variable (LongInt)]
Ofs(§|) {? var X}
[Ord |b System:: Return ordinal value of an ordinal type (LongInt)]
Ord(§|) {? X: TOrdinal}
[Paramcount |b System:: Return number of command-line parameters passed to the program (LongInt)]
Paramcount
[ParamStr |b System:: Return value of a command-line argument (String)]
ParamStr(§|) {? l: LongInt}
[Pi |b System:: Return the value of PI (ValReal)]
Pi
[Pos |b System:: Search for substring in a string (SizeInt)]
Pos(§|,) {? const substr: shortstring|Char|AnsiString; const s: Shortstring|Char|AnsiString)
[Pred |b System:: Return previous element for an ordinal type (TOrdinal)]
Pred(§|) {? X: TOrdinal}
[Prefetch |b System:: Prefetch a memory location]
Prefetch(§|) {? const mem}
[Ptr |b System:: Combine segment and offset to pointer (FarPointer)]
Ptr(§|,) {? sel: LongInt; off: LongInt}
[RaiseList |b System:: List of currently raised exceptions (PExceptObject)]
RaiseList
[Random |b System:: Generate random number (LongInt|Int64|Extended)]
Random(§|) {? optional l: LongInt|int64)
[Randomize |b System:: Initialize random number generator]
Randomize
[Read |b System:: Read from a text file into variable]
Read(§|,) {? optional var F: Text; Args: Arguments)
[ReadLn |b System:: Read from a text file into variable and goto next line]
ReadLn(§|,) {? optional var F: Text; Args: Arguments)
[Real2Double |b System:: Convert Turbo Pascal style real to double (Double)]
Real2Double(§|) {? r: real48}
[ReAllocMem |b System:: Re-allocate memory on the heap (Pointer)]
ReAllocMem(§|,) {? var p: pointer; Size: PtrInt}
[ReAllocMemory |b System:: Alias for ReAllocMem (pointer)]
ReAllocMemory(§|,) {? var p: pointer; Size: PtrInt}
[ReleaseExceptionObject |b System:: Decrease the reference count of the current exception object.]
ReleaseExceptionObject
[Rename |b System:: Rename file on disk]
Rename(§|,) {? var f: File|TypedFile|Text; const s: String|Pchar|Char}
[Reset |b System:: Open file for reading]
Reset(§|,) {? var f: File|TypedFile|Text; optional; l: LongInt}
[ResumeThread |b System:: Resume a suspended thread (DWord)]
ResumeThread(§|) {? threadHandle: TThreadID}
[Rewrite |b System:: Open file for writing]
Rewrite(§|,) {? var f: File|TypedFile|Text; optional l: LongInt}
[RmDir |b System:: Remove directory when empty.]
RmDir(§|) {? const s: String}
[Round |b System:: Round floating point value to nearest integer number (Int64)]
Round(§|) {? d: ValReal}
[RTLEventCreate |b System:: Create a new RTL event (PRTLEvent)]
RTLEventCreate
[RTLEventdestroy |b System:: Destroy a RTL Event]
RTLEventDestroy(§|) {? state: PRTLEvent)
[RTLEventResetEvent |b System:: Reset an event]
RTLeventResetEvent(§|) {? state: PRTLEvent)
[RTLEventSetEvent |b System:: Notify threads of the event.]
RTLeventSetEvent(§|) {? state: PRTLEvent)
[RTLEventStartWait |b System:: Prepare the event for waiting.]
RTLeventStartWait(§|) {? state: PRTLEvent)
[RTLEventSync |b System:: Obsolete. Don't use]
RTLeventsync(§|,) {? m: trtlmethod; p: TProcedure)
[RTLEventWaitFor |b System:: Wait for an event.]
RTLeventWaitFor(§|,) {? state: PRTLEvent; optional timeout: LongInt)
[RunError§|) {?  |b System:: Generate a run-time error.]
RunError(§|) {? optional w: Word}
[Seek |b System:: Set file position]
Seek(§|) {? var f: File; Pos: LongInt}
[SeekEOF |b System:: Set file position to end of file (Boolean)]
SeekEOF(§|) {? optional var t: Text}
[SeekEOLn |b System:: Set file position to end of line (Boolean)]
SeekEOLn(§|) {? optional var t: Text}
[Seg |b System:: Return segment (Longint)]
Seg(§|) {? var X}
[SetJmp |b System:: Save current execution point (Longint)]
SetJmp(§|) {? var S: jmp_buf}
[SetLength |b System:: Set length of a string.]
SetLength(§|,) {? var S: ShortString|Ansistring; len: SizeInt}
[SetMemoryManager |b System:: Set a memory manager]
SetMemoryManager(§|) {? const MemMgr: TMemoryManager}
[SetMemoryMutexManager |b System:: Procedure to set the mutex manager.]
SetMemoryMutexManager(§|) {? var MutexMgr: TMemoryMutexManager}
[SetNoThreadManager |b System:: Clear the threadmanager]
SetNoThreadManager
[SetString |b System:: Set length of a string and copy buffer.]
SetString(§|,,) {? var S: Shortstring|Ansistring; Buf: PChar; Len: SizeInt}
[SetTextBuf |b System:: Set size of text file internal buffer]
SetTextBuf(§|,,) {? var f: Text; var Buf; optional Size: LongInt}
[SetTextLineEnding |b System:: Set the end-of-line character for the given text file.]
SetTextLineEnding(§|,) {? var f: Text; Ending: String}
[SetThreadManager |b System:: Set the thread manager, optionally return the current thread manager (Boolean)]
SetThreadManager(§|,) {? const NewTM: TThreadManager; optional var OldTM: TThreadManager}
[SetVariantManager |b System:: Set the current variant manager.]
SetVariantManager(§|) {? const VarMgr: tvariantmanager}
[Sin |b System:: Calculate sine of angle (ValrReal)]
Sin(§|) {? d: ValReal}
[SizeOf |b System:: Return size of a variable or type (Longint)]
SizeOf(§|) {? X: TAnyType}
[Space |b System:: Return a string of spaces (ShortString)]
Space(§|) {? b: Byte}
[Sptr |b System:: Return current stack pointer (Pointer)]
Sptr
[Sqr |b System:: Calculate the square of a value (Longint|Int64|QWord|Valreal)]
Sqr(§|) {? l: LongInt|Inte64|QWord|ValReal}
[Sqrt |b System:: Calculate the square root of a value (Real)]
Sqrt(§|) {? d: ValReal}
[Sseg |b System:: Return stack segment register value (Word)]
Sseg
[Str |b System:: Convert a numerical value to a string.]
Str(§|,) {? var X: TNumericType; var S: String}
[StringOfChar |b System:: Return a string consisting of 1 character repeated N times (AnsiString)]
StringOfChar(§|,) {? c: Char; l: SizeInt}
[StringToPPChar |b System:: Split string in list of null-terminated strings (PPChar)]
StringToPPChar(§|,) {? var S: AnsiString|Pchar; ReserveEntries: Integer} 
[StrLen |b System:: Length of a null-terminated string (Longint)]
StrLen(§|) {? p: PChar}
[StrPas |b System:: Convert a null-terminated string to a shortstring (Shortstring)]
StrPas(§|) {? p: PChar}
[Succ |b System:: Return next element of ordinal type (Ordinal)]
Succ(§|) {? x: TOrdinal}
[SuspendThread |b System:: Suspend a running thread (DWord)]
SuspendThread(§|) {? threadHandle: TThreadID}
[Swap |b System:: Swap high and low bytes/words of a variable (Word|Integer|Longint|Cardinal|QWord|Int64)]
Swap(§|) {? X: Word|Integer|Longint|Cardinal|Qword|Int64}
[SysAllocMem |b System:: System memory manager: Allocate memory (Pointer)]
SysAllocMem(§|) {? size: PtrInt}
[SysAssert |b System:: Standard Assert failure implementation]
SysAssert(§|,,,) {? const Msg: ShortString; const FName: ShortString; LineNo: LongInt; ErrorAddr: Pointer}
[SysBackTraceStr |b System:: Format an address suitable for inclusion in a backtrace (ShortString)]
SysBackTraceStr(§|) {? Addr: Pointer}
[SysFreemem |b System:: System memory manager free routine (PtrInt)]
SysFreemem(§|) {? p: pointer}
[SysFreememSize |b System:: System memory manager free routine (PtrInt)]
SysFreememSize(§|,) {? p: pointer; Size: PtrInt} 
[SysGetHeapStatus |b System:: System implementation of GetHeapStatus]
SysGetHeapStatus(§|) {? var status: THeapStatus}
[SysGetmem |b System:: System memory manager memory allocator (Pointer)]
SysGetMem(§|) {? Size: PtrInt}
[SysInitExceptions |b System:: Initialize exceptions.]
SysInitExceptions
[SysInitStdIO |b System:: Initialize standard input and output.]
SysInitStdIO
[SysMemSize |b System:: System memory manager: free size (PtrInt)]
SysMemSize(§|) {? p: pointer}
[SysReAllocMem |b System:: System memory manager: Reallocate memory (Pointer)]
SysReAllocMem(§|,) {? var p: pointer; size: PtrInt}
[SysResetFPU |b System:: Reset the floating point unit.]
SysResetFPU
[SysTryResizeMem |b System:: System memory manager: attempt to resize memory (Boolean)]
SysTryResizeMem(§|,) {? var p: pointer; size: PtrInt}
[ThreadGetPriority |b System:: Return the priority of a thread (LongInt)]
ThreadGetPriority(§|) {? threadHandle: TThreadID}
[ThreadSetPriority |b System:: Set the priority of a thread (Boolean)]
ThreadSetPriority(§|,) {? threadHandle: TThreadID; Prio: LongInt}
[ThreadSwitch |b System:: Signal possibility of thread switch]
ThreadSwitch
[Trunc |b System:: Truncate a floating point value (Int64)]
Trunc(§|) {? d: ValReal}
[Truncate |b System:: Truncate the file at position]
Truncate(§|) {? var F: File}
[UniqueString |b System:: Make sure reference count of string is 1]
UniqueString(§|) {? var S: AnsiString}
[UpCase |b System:: Convert a string to all uppercase (Shortstring|Char|Ansistring)]
UpCase(§|) {? const s: ShortString|Char|Ansistring}
[Val |b System:: Calculate numerical value of a string.]
Val(§|,,) {? const S: String; var V; var Code: Word}
[VarArrayRedim |b System:: Redimension a variant array]
VarArrayRedim(§|,) {? var A: Variant; HighBound: SizeInt}
[WaitForThreadTerminate |b System:: Wait for a thread to terminate (DWord)]
WaitForThreadTerminate(§|,) {? threadHandle: TThreadID; TimeoutMs: LongInt}
[Write |b System:: Write variable to a text file]
Write(§|,) {? optional var F: Text; Args: Arguments}
[WriteLn |b System:: Write variable to a text file and append newline]
WriteLn(§|,) {? optional var F: Text; Args: Arguments}

[Argv |f System:: Pointer to the array of command-line arguments]
Argv
[DispCallByIDProc |f System:: Callback to perform dispatch interface procedure call by ID.]
DispCallByIDProc
[Envp |f System:: Pointer to the array of environment variables]
Envp
[ErrOutput |f System:: Alias for StdErr]
ErrOutput
[ExitCode |f System:: Exit code for the program, will be communicated to the OS on exit.]
ExitCode
[InOutRes |f System:: Result of last I/O operation. Read-Only.]
InOutRes
[Input |f System:: Standard input text file.]
Input
[IsConsole |f System:: True for console applications, False for GUI applications.]
IsConsole
[IsLibrary |f System:: True if the current module is a library. Otherwise module is an excutable]
IsLibrary
[Null |f System:: Null variant]
Null
[Output |f System:: Standard output text file.]
Output
[RandSeed |f System:: Seed for Random function.]
RandSeed
[ReturnNilIfGrowHeapFails |f System:: Describe behaviour if getmem fails.]
ReturnNilIfGrowHeapFails
[StackBottom |f System:: Current stack bottom.]
StackBottom
[StackLength |f System:: Maximum stack length.]
StackLength
[StdErr |f System:: Standard diagnostic output text file.]
StdErr
[StdOut |f System:: Alias for Output.]
StdOut
[ThreadID |f System:: Current Thread ID.]
ThreadID
[Unassigned |f System:: Unassigned variant.]
Unassigned
[VarDispProc |f System:: Callback to perform dispatch interface procedure call by name.]
VarDispProc

;==============================================================================================
;   Unit: Dateutils
;==============================================================================================

[ApproxDaysPerMonth |r Dateutils:: Average number of days in a month, measured over a year. Used in MonthsBetween.]
ApproxDaysPerMonth
[ApproxDaysPerYear |r Dateutils:: Average number of days in a year, measured over 4 years. Used in YearsBetween.]
ApproxDaysPerYear
[DayFriday |r Dateutils:: ISO day number for Friday]
DayFriday
[DayMonday |r Dateutils:: ISO day number for Monday]
DayMonday
[DaySaturday |r Dateutils:: ISO day number for Saturday]
DaySaturday
[DaysPerWeek |r Dateutils:: Number of days in a week.]
DaysPerWeek
[DaysPerYear |r Dateutils:: Array with number of days in a year. The boolean index indicates whether it is a leap year or not.]
DaysPerYear
[DaySunday |r Dateutils:: ISO day number for Sunday]
DaySunday
[DayThursday |r Dateutils:: ISO day number for Thursday]
DayThursday
[DayTuesday |r Dateutils:: ISO day number for Tuesday]
DayTuesday
[DayWednesday |r Dateutils:: ISO day number for Wednesday]
DayWednesday
[MonthsPerYear |r Dateutils:: Number of months in a year]
MonthsPerYear
[OneHour |r Dateutils:: One hour as a fraction of a day (suitable for TDateTime)]
OneHour
[OneMillisecond |r Dateutils:: One millisecond as a fraction of a day (suitable for TDateTime)]
OneMillisecond
[OneMinute |r Dateutils:: One minute as a fraction of a day (suitable for TDateTime)]
OneMinute
[OneSecond |r Dateutils:: One second as a fraction of a day (suitable for TDateTime)]
OneSecond
[RecodeLeaveFieldAsIs |r Dateutils:: Bitmask deciding what to do with each TDateTime field in recode routines]
RecodeLeaveFieldAsIs
[WeeksPerFortnight |r Dateutils:: Number of weeks in fortnight]
WeeksPerFortnight
[YearsPerCentury |r Dateutils:: Number of years in a century]
YearsPerCentury
[YearsPerDecade |r Dateutils:: Number of years in a decade]
YearsPerDecade
[YearsPerMillennium |r Dateutils:: Number of years in a millenium]
YearsPerMillennium

[CompareDate |b Dateutils:: Compare 2 dates, disregarding the time of day (TValueRelationship)]
CompareDate(§|,) {? const A: TDateTime; const B: TDateTime}
[CompareDateTime |b Dateutils:: Compare 2 dates, taking into account the time of day (TValueRelationship)]
CompareDateTime(§|,) {? const A: TDateTime; const B: TDateTime}
[CompareTime |b Dateutils:: Compares two times of the day, disregarding the date part (TValueRelationship).]
CompareTime(§|,) {? const A: TDateTime; const B: TDateTime}
[DateOf |b Dateutils:: Extract the date part from a DateTime indication (TDateTime).]
DateOf(§|) {? const AValue: TDateTime}
[DateTimeToJulianDate |b Dateutils:: Converts a TDateTime value to a Julian date representation (Double)]
DateTimeToJulianDate(§|) {? const AValue: TDateTime}
[DateTimeToModifiedJulianDate |b Dateutils:: Convert a TDateTime value to a modified Julian date representation (Double)]
DateTimeToModifiedJulianDate(§|) {? const AValue: TDateTime}
[DateTimeToUnix |b Dateutils:: Convert a TDateTime value to Unix epoch time (Int64)]
DateTimeToUnix(§|) {? const AValue: TDateTime}
[DayOf |b Dateutils:: Extract the day (of month) part from a DateTime value (Word)]
DayOf(§|) {? const AValue: TDateTime}
[DayOfTheMonth |b Dateutils:: Extract the day (of month) part of a DateTime value (Word)]
DayOfTheMonth(§|) {? const AValue: TDateTime}
[DayOfTheWeek |b Dateutils:: Extracts the day of the week from a DateTime value (Word)]
DayOfTheWeek(§|) {? const AValue: TDateTime}
[DayOfTheYear |b Dateutils:: Extracts the day of the year from a TDateTime value (Word)]
DayOfTheYear(§|) {? const AValue: TDateTime}
[DaysBetween |b Dateutils:: Number of whole days between two DateTime values (Integer).]
DaysBetween(§|,) {? const ANow: TDateTime; const AThen: TDateTime}
[DaysInAMonth |b Dateutils:: Number of days in a month of a certain year (Word).]
DaysInAMonth(§|,) {? const AYear: Word; const AMonth: Word}
[DaysInAYear |b Dateutils:: Number of days in a particular year (Word).]
DaysInAYear(§|) {? const AYear: Word}
[DaysInMonth |b Dateutils:: Return the number of days in the month in which a date occurs (Word).]
DaysInMonth(§|) {? const AValue: TDateTime}
[DaysInYear |b Dateutils:: Return the number of days in the year in which a date occurs (Word).]
DaysInYear(§|) {? const AValue: TDateTime}
[DaySpan |b Dateutils:: Calculate the approximate number of days between two DateTime values (Double).]
DaySpan(§|,) {? const ANow: TDateTime; const AThen: TDateTime}
[DecodeDateDay |b Dateutils:: Decode a DateTime value in year and year of day.]
DecodeDateDay(§|,,) {? const AValue: TDateTime; var AYear: Word; var ADayOfYear: Word}
[DecodeDateMonthWeek |b Dateutils:: Decode a DateTime value in a month, week of month and day of week]
DecodeDateMonthWeek(§|,,,,) {? const AValue: TDateTime; var AYear: Word; var AMonth: Word; var AWeekOfMonth: Word; var ADayOfWeek: Word}
[DecodeDateTime |b Dateutils:: Decode a datetime value in a date and time value]
procedure DecodeDateTime(§|,,,,,,,) {? const AValue: TDateTime; var AYear: Word; var AMonth: Word; var ADay: Word;var AHour: Word; var AMinute: Word;var ASecond: Word; var AMilliSecond: Word}
[DecodeDateWeek |b Dateutils:: Decode a DateTime value in a week of year and day of week.]
DecodeDateWeek(§|,,,) {? const AValue: TDateTime; var AYear: Word; var AWeekOfYear: Word; var ADayOfWeek: Word}
[DecodeDayOfWeekInMonth |b Dateutils:: Decode a DateTime value in year, month, day of week parts]
DecodeDayOfWeekInMonth(§|,,,,) {? const AValue: TDateTime; var AYear: Word; var AMonth: Word; var ANthDayOfWeek: Word; var ADayOfWeek: Word}
[EncodeDateDay |b Dateutils:: Encodes a year and day of year to a DateTime value (TDateTime)]
EncodeDateDay(§|,) {? const AYear: Word; const ADayOfYear: Word}
[EncodeDateMonthWeek |b Dateutils:: Encodes a year, month, week of month and day of week to a DateTime value (TDateTime)]
EncodeDateMonthWeek(§|,,,) {? const AYear: Word; const AMonth: Word; const AWeekOfMonth: Word; const ADayOfWeek: Word}
[EncodeDateTime |b Dateutils:: Encodes a DateTime value from all its parts (TDateTime)]
EncodeDateTime(§|,,,,,,) {? const AYear: Word; const AMonth: Word; const ADay: Word; const AHour: Word; const AMinute: Word; const ASecond: Word; const AMilliSecond: Word}
[EncodeDateWeek |b Dateutils:: Encode a TDateTime value from a year, week and day of week triplet (TDateTime)]
EncodeDateWeek(§|,,) {? const AYear: Word; const AWeekOfYear: Word; optional const ADayOfWeek: Word}
[EncodeDayOfWeekInMonth |b Dateutils:: Encodes a year, month, week, day of week specification to a TDateTime value (TDateTime)]
EncodeDayOfWeekInMonth(§|,,,) {? const AYear: Word; const AMonth: Word; const ANthDayOfWeek: Word; const ADayOfWeek: Word}
[EndOfADay |b Dateutils:: Calculates a DateTime value representing the end of a specified day (TDateTime)]
EndOfADay(§|,,) {? const AYear: Word; const AMonth: Word; const ADay: Word}
[EndOfAMonth |b Dateutils:: Calculate a datetime value representing the last day of the indicated month (TDateTime)]
EndOfAMonth(§|,) {? const AYear: Word; const AMonth: Word}
[EndOfAWeek |b Dateutils:: Return the last moment of day of the week, given a year and a week in the year (TDateTime).]
EndOfAWeek(§|,,) {? const AYear: Word; const AWeekOfYear: Word; optional const ADayOfWeek: Word}
[EndOfAYear |b Dateutils:: Calculate a DateTime value representing the last day of a year (TDateTime)]
EndOfAYear(§|) {? const AYear: Word}
[EndOfTheDay |b Dateutils:: Calculate a datetime value that represents the end of a given day (TDateTime).]
function EndOfTheDay(§|) {? const AValue: TDateTime}
[EndOfTheMonth |b Dateutils:: Calculate a DateTime value representing the last day of the month, given a day in that month (TDateTime).]
EndOfTheMonth(§|) {? const AValue: TDateTime}
[EndOfTheWeek |b Dateutils:: Calculate a DateTime value which represents the end of a week, given a date in that week (TDateTime).]
EndOfTheWeek(§|) {? const AValue: TDateTime}
[EndOfTheYear |b Dateutils:: Calculate a DateTime value representing the last day of a year, given a date in that year (TDateTime).]
EndOfTheYear(§|) {? const AValue: TDateTime}
[HourOf |b Dateutils:: Extract the hour part from a DateTime value (Word).]
HourOf(§|) {? const AValue: TDateTime}
[HourOfTheDay |b Dateutils:: Calculate the hour of a given DateTime value (Word)]
HourOfTheDay(§|) {? const AValue: TDateTime}
[HourOfTheMonth |b Dateutils:: Calculate the number of hours passed since the start of the month (Word).]
HourOfTheMonth(§|) {? const AValue: TDateTime}
[HourOfTheWeek |b Dateutils:: Calculate the number of hours elapsed since the start of the week (Word).]
HourOfTheWeek(§|) {? const AValue: TDateTime}
[HourOfTheYear |b Dateutils:: Calculate the number of hours passed since the start of the year (Word).]
HourOfTheYear(§|) {? const AValue: TDateTime}
[HoursBetween |b Dateutils:: Calculate the number of whole hours between two DateTime values (Int64).]
HoursBetween(§|,) {? const ANow: TDateTime; const AThen: TDateTime}
[HourSpan |b Dateutils:: Calculate the approximate number of hours between two DateTime values (Double).]
HourSpan(§|,) {? const ANow: TDateTime; const AThen: TDateTime}
[IncDay |b Dateutils:: Increase a DateTime value with a number of days (TDateTime).]
IncDay(§|,) {? const AValue: TDateTime; optional const ANumberOfDays: Integer}
[IncHour |b Dateutils:: Increase a DateTime value with a number of hours (TDateTime).]
IncHour(§|,) {? const AValue: TDateTime; optional const ANumberOfHours: Int64}
[IncMilliSecond |b Dateutils:: Increase a DateTime value with a number of milliseconds (TDateTime).]
IncMilliSecond(§|,) {? const AValue: TDateTime; optional const ANumberOfMilliSeconds: Int64}
[IncMinute |b Dateutils:: Increase a DateTime value with a number of minutes (TDateTime).]
IncMinute(§|,) {? const AValue: TDateTime; optional const ANumberOfMinutes: Int64}
[IncSecond |b Dateutils:: Increase a DateTime value with a number of seconds (TDateTime).]
IncSecond(§|,) {? const AValue: TDateTime; optional const ANumberOfSeconds: Int64}
[IncWeek |b Dateutils:: Increase a DateTime value with a number of weeks (TDateTime).]
IncWeek(§|,) {? const AValue: TDateTime; optional const ANumberOfWeeks: Integer}
[IncYear |b Dateutils:: Increase a DateTime value with a number of years (TDateTime).]
IncYear(§|,) {? const AValue: TDateTime; optional const ANumberOfYears: Integer}
[InvalidDateDayError |b Dateutils:: Raise an EConvertError exception when a day is not a valid day of a year.]
InvalidDateDayError(§|,) {? const AYear: Word; const ADayOfYear: Word}
[InvalidDateMonthWeekError |b Dateutils:: Raise an EConvertError exception when a Year,Month,WeekOfMonth,DayofWeek is invalid.]
InvalidDateMonthWeekError(§|,,,) {? const AYear: Word; const AMonth: Word; const AWeekOfMonth: Word; const ADayOfWeek: Word}
[InvalidDateTimeError |b Dateutils:: Raise an EConvertError about an invalid date-time specification.]
InvalidDateTimeError(§|,,,,,,,) {? const AYear: Word; const AMonth: Word; const ADay: Word; const AHour: Word; const AMinute: Word; const ASecond: Word; const AMilliSecond: Word; optional const ABaseDate: TDateTime}
[InvalidDateWeekError |b Dateutils:: Raise an EConvertError with an invalid Year, WeekOfyear and DayOfWeek specification]
InvalidDateWeekError(§|,,) {? const AYear: Word; const AWeekOfYear: Word; const ADayOfWeek: Word}
[InvalidDayOfWeekInMonthError |b Dateutils:: Raise an EConvertError exception when a Year,Month,NthDayofWeek,DayofWeek is invalid.]
InvalidDayOfWeekInMonthError(§|,,,) {? const AYear: Word; const AMonth: Word; const ANthDayOfWeek: Word; const ADayOfWeek: Word}
[IsInLeapYear |b Dateutils:: Determine whether a date is in a leap year (Boolean).]
IsInLeapYear(§|) {? const AValue: TDateTime}
[IsPM |b Dateutils:: Determine whether a time is PM or AM (Boolean).]
IsPM(const AValue: TDateTime}
[IsSameDay |b Dateutils:: Check if two date/time indications are the same day (Boolean).]
IsSameDay(§|,) {? const AValue: TDateTime; const ABasis: TDateTime}
[IsToday |b Dateutils:: Check whether a given date is today (Boolean).]
IsToday(§|) {? const AValue: TDateTime}
[IsValidDate |b Dateutils:: Check whether a set of values is a valid date indication (Boolean).]
IsValidDate(§|,,) {? const AYear: Word; const AMonth: Word; const ADay: Word}
[IsValidDateDay |b Dateutils:: Check whether a given year/day of year combination is a valid date (Boolean).]
IsValidDateDay(§|,) {? const AYear: Word; const ADayOfYear: Word}
[IsValidDateMonthWeek |b Dateutils:: Check whether a given year/month/week/day of the week combination is a valid day (Boolean)]
IsValidDateMonthWeek(§|,,,) {? const AYear: Word; const AMonth: Word; const AWeekOfMonth: Word; const ADayOfWeek: Word}
[IsValidDateTime |b Dateutils:: Check whether a set of values is a valid date and time indication (Boolean).]
IsValidDateTime(§|,,,,,,) {? const AYear: Word; const AMonth: Word; const ADay: Word; const AHour: Word; const AMinute: Word; const ASecond: Word; const AMilliSecond: Word}
[IsValidDateWeek |b Dateutils:: Check whether a given year/week/day of the week combination is a valid day (Boolean).]
IsValidDateWeek(§|,,) {? const AYear: Word; const AWeekOfYear: Word; const ADayOfWeek: Word}
[IsValidTime |b Dateutils:: Check whether a set of values is a valid time indication (Boolean).]
IsValidTime(§|,,,) {? const AHour: Word; const AMinute: Word; const ASecond: Word; const AMilliSecond: Word}
[JulianDateToDateTime |b Dateutils:: Convert a Julian date representation to a TDateTime value (TDateTime).]
JulianDateToDateTime(§|) {? const AValue: Double}
[MilliSecondOf |b Dateutils:: Extract the millisecond part from a DateTime value (Word).]
MilliSecondOf(§|) {? const AValue: TDateTime}
[MilliSecondOfTheDay |b Dateutils:: Calculate the number of milliseconds elapsed since the start of the day (LongWord)]
MilliSecondOfTheDay(§|) {? const AValue: TDateTime}
[MilliSecondOfTheHour |b Dateutils:: Calculate the number of milliseconds elapsed since the start of the hour (LongWord)]
MilliSecondOfTheHour(§|) {? const AValue: TDateTime}
[MilliSecondOfTheMinute |b Dateutils:: Calculate the number of milliseconds elapsed since the start of the minute (LongWord)]
MilliSecondOfTheMinute(§|) {? const AValue: TDateTime}
[MilliSecondOfTheMonth |b Dateutils:: Calculate number of milliseconds elapsed since the start of the month (LongWord).]
MilliSecondOfTheMonth(§|) {? const AValue: TDateTime}
[MilliSecondOfTheSecond |b Dateutils:: Calculate the number of milliseconds elapsed since the start of the second (Word)]
MilliSecondOfTheSecond(§|) {? const AValue: TDateTime}
[MilliSecondOfTheWeek |b Dateutils:: Calculate the number of milliseconds elapsed since the start of the week (LongWord)]
MilliSecondOfTheWeek(§|) {? const AValue: TDateTime}
[MilliSecondOfTheYear |b Dateutils:: Calculate the number of milliseconds elapsed since the start of the year (Int64).]
MilliSecondOfTheYear(§|) {? const AValue: TDateTime}
[MilliSecondsBetween |b Dateutils:: Calculate the number of whole milliseconds between two DateTime values (Int64).]
MilliSecondsBetween(§|,) {? const ANow: TDateTime; const AThen: TDateTime}
[MilliSecondSpan |b Dateutils:: Calculate the approximate number of milliseconds between two DateTime values (Double).]
MilliSecondSpan(§|,) {? const ANow: TDateTime; const AThen: TDateTime}
[MinuteOf |b Dateutils:: Extract the minute part from a DateTime value (Word).]
MinuteOf(§|) {? const AValue: TDateTime}
[MinuteOfTheDay |b Dateutils:: Calculate the number of minutes elapsed since the start of the day (Word)]
MinuteOfTheDay(§|) {? const AValue: TDateTime}
[MinuteOfTheHour |b Dateutils:: Calculate the number of minutes elapsed since the start of the hour (Word)]
MinuteOfTheHour(§|) {? const AValue: TDateTime}
[MinuteOfTheMonth |b Dateutils:: Calculate number of minutes elapsed since the start of the month (Word).]
MinuteOfTheMonth(§|) {? const AValue: TDateTime}
[MinuteOfTheWeek |b Dateutils:: Calculate the number of minutes elapsed since the start of the week (Word)]
MinuteOfTheWeek(§|) {? const AValue: TDateTime}
[MinuteOfTheYear |b Dateutils:: Calculate the number of minutes elapsed since the start of the year (LongWord)]
MinuteOfTheYear(§|) {? const AValue: TDateTime}
[MinutesBetween |b Dateutils:: Calculate the number of whole minutes between two DateTime values (Int64).]
MinutesBetween(§|,) {? const ANow: TDateTime; const AThen: TDateTime}
[MinuteSpan |b Dateutils:: Calculate the approximate number of minutes between two DateTime values (Double).]
MinuteSpan(§|,) {? const ANow: TDateTime; const AThen: TDateTime}
[ModifiedJulianDateToDateTime |b Dateutils:: Convert a modified Julian date representation to a TDateTime value (TDateTime).]
ModifiedJulianDateToDateTime(§|) {? const AValue: Double}
[MonthOf |b Dateutils:: Extract the month from a given date (Word).]
MonthOf(§|) {? const AValue: TDateTime}
[MonthOfTheYear |b Dateutils:: Extract the month of a DateTime indication (Word).]
MonthOfTheYear(§|) {? const AValue: TDateTime}
[MonthsBetween |b Dateutils:: Calculate the number of whole months between two DateTime values (Integer)]
MonthsBetween(§|,) {? const ANow: TDateTime; const AThen: TDateTime}
[MonthSpan |b Dateutils:: Calculate the approximate number of months between two DateTime values (Double).]
MonthSpan(§|,) {? const ANow: TDateTime; const AThen: TDateTime}
[NthDayOfWeek |b Dateutils:: Calculate which occurrence of weekday in the month a given day represents (Word)]
NthDayOfWeek(§|) {? const AValue: TDateTime}
[PreviousDayOfWeek |b Dateutils:: Given a day of the week, return the previous day of the week (Word).]
PreviousDayOfWeek(§|) {? DayOfWeek: Word}
[RecodeDate |b Dateutils:: Replace date part of a TDateTime value with another date (TDateTime).]
RecodeDate(§|,,,) {? const AValue: TDateTime; const AYear: Word; const AMonth: Word; const ADay: Word}
[RecodeDateTime |b Dateutils:: Replace selected parts of a TDateTime value with other values (TDateTime)]
RecodeDateTime(§|,,,,,,,) {? const AValue: TDateTime; const AYear: Word; const AMonth: Word; const ADay: Word; const AHour: Word; const AMinute: Word; const ASecond: Word; const AMilliSecond: Word}
[RecodeDay |b Dateutils:: Replace day part of a TDateTime value with another day (TDateTime).]
RecodeDay(§|,) {? const AValue: TDateTime; const ADay: Word}
[RecodeHour |b Dateutils:: Replace hours part of a TDateTime value with another hour (TDateTime).]
RecodeHour(§|,) {? const AValue: TDateTime; const AHour: Word}
[RecodeMilliSecond |b Dateutils:: Replace milliseconds part of a TDateTime value with another millisecond (TDateTime).]
RecodeMilliSecond(§|,) {? const AValue: TDateTime; const AMilliSecond: Word}
[RecodeMinute |b Dateutils:: Replace minutse part of a TDateTime value with another minute (TDateTime).]
RecodeMinute(§|,) {? const AValue: TDateTime; const AMinute: Word}
[RecodeMonth |b Dateutils:: Replace month part of a TDateTime value with another month (TDateTime).]
RecodeMonth(§|,) {? const AValue: TDateTime; const AMonth: Word}
[RecodeSecond |b Dateutils:: Replace seconds part of a TDateTime value with another second (TDateTime)]
RecodeSecond(§|,) {? const AValue: TDateTime; const ASecond: Word}
[RecodeTime |b Dateutils:: Replace time part of a TDateTime value with another time (TDateTime).]
RecodeTime(§|,,,,) {? const AValue: TDateTime; const AHour: Word; const AMinute: Word; const ASecond: Word; const AMilliSecond: Word}
[RecodeYear |b Dateutils:: Replace year part of a TDateTime value with another year (TDateTime).]
RecodeYear(§|,) {? const AValue: TDateTime; const AYear: Word}
[SameDate |b Dateutils:: Check whether two TDateTime values have the same date part (Boolean).]
SameDate(§|,) {? const A: TDateTime; const B: TDateTime}
[SameDateTime |b Dateutils:: Check whether two TDateTime values have the same date and time parts (Boolean).]
SameDateTime(§|,) {? const A: TDateTime; const B: TDateTime}
[SameTime |b Dateutils:: Check whether two TDateTime values have the same time part (Boolean).]
SameTime(§|,) {? const A: TDateTime; const B: TDateTime}
[SecondOf |b Dateutils:: Extract the second part from a DateTime value (Word)]
SecondOf(§|) {? const AValue: TDateTime}
[SecondOfTheDay |b Dateutils:: Calculate the number of seconds elapsed since the start of the day (LongWord)]
SecondOfTheDay(§|) {? const AValue: TDateTime}
[SecondOfTheHour |b Dateutils:: Calculate the number of seconds elapsed since the start of the hour (Word)]
SecondOfTheHour(§|) {? const AValue: TDateTime}
[SecondOfTheMinute |b Dateutils:: Calculate the number of seconds elapsed since the start of the minute (Word)]
SecondOfTheMinute(§|) {? const AValue: TDateTime}
[SecondOfTheMonth |b Dateutils:: Calculate number of seconds elapsed since the start of the month (LongWord)]
SecondOfTheMonth(§|) {? const AValue: TDateTime}
[SecondOfTheWeek |b Dateutils:: Calculate the number of seconds elapsed since the start of the week (LongWord)]
SecondOfTheWeek(§|) {? const AValue: TDateTime}
[SecondOfTheYear |b Dateutils:: Calculate the number of seconds elapsed since the start of the year (LongWord).]
SecondOfTheYear(§|) {? const AValue: TDateTime}
[SecondsBetween |b Dateutils:: Calculate the number of whole seconds between two DateTime values (Int64).]
SecondsBetween(§|,) {? const ANow: TDateTime; const AThen: TDateTime}
[SecondSpan |b Dateutils:: Calculate the approximate number of seconds between two DateTime values (Double).]
SecondSpan(§|,) {? const ANow: TDateTime; const AThen: TDateTime}
[StartOfADay |b Dateutils:: Return the start of a day as a DateTime value, given a day indication (TDateTime)]
StartOfADay(§|,,) {? const AYear: Word; optional const AMonth: Word; const ADay: Word}
[StartOfAMonth |b Dateutils:: Return first date of month, given a year/month pair (TDateTime).]
StartOfAMonth(§|,) {? const AYear: Word; const AMonth: Word}
[StartOfAWeek |b Dateutils:: Return a day of the week, given a year, week and day in the week (TDateTime).]
StartOfAWeek(§|,,) {? const AYear: Word; const AWeekOfYear: Word; optional const ADayOfWeek: Word}
[StartOfAYear |b Dateutils:: Return the first day of a given year (TDateTime).]
StartOfAYear(§|) {? const AYear: Word}
[StartOfTheDay |b Dateutils:: Calculate the start of the day as a DateTime value, given a moment in the day (TDateTime).]
StartOfTheDay(§|) {? const AValue: TDateTime}
[StartOfTheMonth |b Dateutils:: Calculate the first day of the month, given a date in that month (TDateTime).]
StartOfTheMonth(§|) {? const AValue: TDateTime}
[StartOfTheWeek |b Dateutils:: Return the first day of the week, given a date (TDateTime).]
StartOfTheWeek(§|) {? const AValue: TDateTime}
[StartOfTheYear |b Dateutils:: Return the first day of the year, given a date in this year (TDateTime).]
StartOfTheYear(§|) {? const AValue: TDateTime}
[TimeOf |b Dateutils:: Extract the time part from a DateTime indication (TDateTime)]
function TimeOf(§|) {? const AValue: TDateTime}
[Today |b Dateutils:: Return the current date (TDateTime)]
Today
[Tomorrow |b Dateutils:: Return the next day (TDateTime)]
Tomorrow
[TryEncodeDateDay |b Dateutils:: Encode a year and day of year to a TDateTime value (Boolean)]
TryEncodeDateDay(§|,,) {? const AYear: Word; const ADayOfYear: Word; var AValue: TDateTime}
[TryEncodeDateMonthWeek |b Dateutils:: Encode a year, month, week of month and day of week to a TDateTime value (Boolean)]
TryEncodeDateMonthWeek(§|,,,,) {? const AYear: Word; const AMonth: Word; const AWeekOfMonth: Word; const ADayOfWeek: Word; var AValue: TDateTime}
[TryEncodeDateTime |b Dateutils:: Encode a Year, Month, Day, Hour, minute, seconds, milliseconds tuplet to a TDateTime value (Boolean)]
TryEncodeDateTime(§|,,,,,,,) {? const AYear: Word; const AMonth: Word; const ADay: Word; const AHour: Word; const AMinute: Word; const ASecond: Word; const AMilliSecond: Word; var AValue: TDateTime} 
[TryEncodeDateWeek |b Dateutils:: Encode a year, week and day of week triplet to a TDateTime value (Boolean)]
TryEncodeDateWeek(§|,,,) {? const AYear: Word; const AWeekOfYear: Word; var AValue: TDateTime; optional const ADayOfWeek: Word}
[TryEncodeDayOfWeekInMonth |b Dateutils:: Encode a year, month, week, day of week triplet to a TDateTime value (Boolean)]
TryEncodeDayOfWeekInMonth(§|,,,,) {? const AYear: Word; const AMonth: Word; const ANthDayOfWeek: Word; const ADayOfWeek: Word; var AValue: TDateTime}
[TryJulianDateToDateTime |b Dateutils:: Convert a Julian date representation to a TDateTime value (Boolean)]
TryJulianDateToDateTime(§|,) {? const AValue: Double; var ADateTime: TDateTime}
[TryModifiedJulianDateToDateTime |b Dateutils:: Convert a modified Julian date representation to a TDateTime value (Boolean)]
TryModifiedJulianDateToDateTime(§|,) {? const AValue: Double; var ADateTime: TDateTime}
[TryRecodeDateTime |b Dateutils:: Replace selected parts of a TDateTime value with other values (Boolean)]
TryRecodeDateTime(§|,,,,,,,,) {? const AValue: TDateTime; const AYear: Word; const AMonth: Word; const ADay: Word; const AHour: Word; const AMinute: Word; const ASecond: Word; const AMilliSecond: Word; var AResult: TDateTime} 
[UnixToDateTime |b Dateutils:: Convert Unix epoch time to a TDateTime value (TDateTime)]
UnixToDateTime(§|) {? const AValue: Int64}
[WeekOf |b Dateutils:: Extract week (of the year) from a given date (Word)]
WeekOf(§|) {? const AValue: TDateTime}
[WeekOfTheMonth |b Dateutils:: Extract the week of the month (and optionally month and year) from a DateTime value (Word)]
WeekOfTheMonth(§|,,) {? const AValue: TDateTime; optional var AYear: Word; var AMonth: Word}
[WeekOfTheYear |b Dateutils:: Extract the week of the year (and optionally year) of a DateTime indication (Word)]
WeekOfTheYear(§|,) {? const AValue: TDateTime; optional var AYear: Word} 
[WeeksBetween |b Dateutils:: Calculate the number of whole weeks between two DateTime values (Integer)] 
WeeksBetween(§|,) {? const ANow: TDateTime; const AThen: TDateTime}
[WeeksInAYear |b Dateutils:: Return the number of weeks in a given year (Word)]
WeeksInAYear(§|) {? const AYear: Word}
[WeeksInYear |b Dateutils:: return the number of weeks in the year, given a date (Word)]
WeeksInYear(§|) {? const AValue: TDateTime}
[WeekSpan |b Dateutils:: Calculate the approximate number of weeks between two DateTime values (Double)]
WeekSpan(§|,) {? const ANow: TDateTime; const AThen: TDateTime}
[WithinPastDays |b Dateutils:: Check whether two datetimes are only a number of days apart (Boolean)]
WithinPastDays(§|,,) {? const ANow: TDateTime; const AThen: TDateTime; const ADays: Integer}
[WithinPastHours |b Dateutils:: Check whether two datetimes are only a number of hours apart (Boolean)]
WithinPastHours(§|,,) {? const ANow: TDateTime; const AThen: TDateTime; const AHours: Int64}
[WithinPastMilliSeconds |b Dateutils:: Check whether two datetimes are only a number of milliseconds apart (Boolean)]
WithinPastMilliSeconds(§|,,) {? const ANow: TDateTime; const AThen: TDateTime; const AMilliSeconds: Int64}
[WithinPastMinutes |b Dateutils:: Check whether two datetimes are only a number of minutes apart (Boolean)]
WithinPastMinutes(§|,,) {? const ANow: TDateTime; const AThen: TDateTime; const AMinutes: Int64}
[WithinPastMonths |b Dateutils:: Check whether two datetimes are only a number of months apart (Boolean)]
WithinPastMonths(§|,,) {? const ANow: TDateTime; const AThen: TDateTime; const AMonths: Integer}
[WithinPastSeconds |b Dateutils:: Check whether two datetimes are only a number of seconds apart (Boolean)]
WithinPastSeconds(§|,,) {? const ANow: TDateTime; const AThen: TDateTime; const ASeconds: Int64}
[WithinPastWeeks |b Dateutils:: Check whether two datetimes are only a number of weeks apart (Boolean)]
WithinPastWeeks(§|,,) {? const ANow: TDateTime; const AThen: TDateTime; const AWeeks: Integer}
[WithinPastYears |b Dateutils:: Check whether two datetimes are only a number of years apart (Boolean)]
WithinPastYears(§|,,) {? const ANow: TDateTime; const AThen: TDateTime; const AYears: Integer}
[YearOf |b Dateutils:: Extract the year from a given date (Word)]
YearOf(§|) {? const AValue: TDateTime}
[YearsBetween |b Dateutils:: Calculate the number of whole years between two DateTime values (Integer)]
YearsBetween(§|,) {? const ANow: TDateTime; const AThen: TDateTime}
[YearSpan |b Dateutils:: Calculate the approximate number of years between two DateTime values (Double)]
YearSpan(§|,) {? const ANow: TDateTime; const AThen: TDateTime}
[Yesterday |b Dateutils:: Return the previous day (TDateTime).]
Yesterday

;==============================================================================================
;   Unit: Math
;==============================================================================================

[EqualsValue |r Math::Values are the same]
EqualsValue
[GreaterThanValue |r Math::First values is greater than second value]
GreaterThanValue
[Infinity |r Math::Value is infinity]
Infinity
[LessThanValue |r Math::First value is less than second value]
LessThanValue
[MaxExtended |r Math::Maximum value of extended type]
MaxExtended
[MaxFloat |r Math::Maximum value of float type]
MaxFloat
[MinExtended |r Math::Minimum value (closest to zero) of extended type]
MinExtended
[MinFloat |r Math::Minimum value (closest to zero) of float type]
MinFloat
[NaN |r Math::Value is Not a Number]
NaN
[NegativeValue |r Math::Value is negative]
NegativeValue
[PositiveValue |r Math::Value is positive]
PositiveValue
[ZeroValue |r Math::Value is zero]
ZeroValue

[Float |p Math::Float type used in all calls]
Float
[PFloat |p Math::Pointer to Float type.]
PFloat
[PInteger |p Math::Pointer to integer type]
PInteger
[TFPUException |p Math::Type describing Floating Point processor exceptions.]
TFPUException
[TFPUExceptionMask |p Math::Type to set the Floating Point Unit exception mask.]
TFPUExceptionMask
[TFPUPrecisionMode |p Math::Type describing the default precision for the Floating Point processor.]
TFPUPrecisionMode
[TFPURoundingMode |p Math::Type describing the rounding mode for the Floating Point processor.]
TFPURoundingMode
[PaymentTime |p Math::Type used in financial (interest) calculations.]
PaymentTime
[TValueRelationship |p Math::Type to describe relational order between values]
TValueRelationship
[TValueSign |p Math::Type indicating sign of a valuea]
TValueSign

[Einvalidargument |g Math:: Exception raised when invalid arguments are passed to a function.]
Einvalidargument

[ArcCos |b Math:: Return inverse cosine (Float)]
ArcCos(§|) {? x: float}
[ArcCosh |b Math:: Return inverse hyperbolic cosine (Float)]
ArcCosh(§|) {? x: float}
[Arcosh |b Math:: Return inverse hyperbolic cosine (Float)]
Arcosh(§|) {? x: float}
[ArcSin |b Math:: Return inverse sine (Float)]
ArcSin(§|) {? x: float}
[ArcSinh |b Math:: Return inverse hyperbolic sine (Float)]
ArcSinh(§|) {? x: float}
[ArcTan2 |b Math:: Return arctangent of y/x (Float)]
ArcTan2(§|) {? y: float; x: float}
[ArcTanh |b Math:: Return inverse hyperbolic tangent (Float)]
ArcTanh(§|) {? x: float}
[Arsinh |b Math:: Return inverse hyperbolic sine (Float)]
Arsinh(§|) {? x: float}
[Artanh |b Math:: Return inverse hyperbolic tangent (Float)]
Artanh(§|) {? x: float}
[Ceil |b Math:: Return the lowest integer number greater than or equal to argument (Integer)]
Ceil(§|) {? x: float}
[ClearExceptions |b Math:: Clear Floating Point Unit exceptions]
ClearExceptions(§|) {? RaisePending: Boolean}
[Cosh |b Math:: Return hyperbolic cosine (Float)]
Cosh(§|) {? x: float}
[Cotan |b Math:: Return cotangent (Float)]
Cotan(§|) {? x: float}
[CycleToRad |b Math:: Convert cycle angle to radians angle (Float)]
CycleToRad(§|) {? cycle: float}
[DegToGrad |b Math:: Convert degree angle to grads angle (Float)]
DegToGrad(§|) {? deg: float}
[DegToRad |b Math:: Convert degree angle to radians angle (Float).]
DegToRad(§|) {? deg: float}
[DivMod |b Math:: Return DIV and MOD of arguments ]
DivMod(§|,,,) {? Dividend: Integer; Divisor: Word; var Result: Word; var Remainder: Word}
[EnsureRange |b Math:: Change value to it falls in specified range (Integer|Int64).]
EnsureRange(§|,,) {? const AValue: Integer|Int64; const AMin: Integer|Int64; const AMax: Integer|Int64}
[Floor |b Math:: Return the largest integer smaller than or equal to argument (Integer)]
Floor(§|) {? x: float}
[Frexp |b Math:: Return mantissa and exponent.]
Frexp(§|,,) {? X: float; var Mantissa: float; var Exponent: Integer}
[GetExceptionMask |b Math:: Get the Floating Point Unit exception mask (TFPUExceptionMask).]
GetExceptionMask
[GetPrecisionMode |b Math:: Return the Floating Point Unit precision mode (TFPUPrecisionMode).]
GetPrecisionMode
[GetRoundMode |b Math:: Return the Floating Point Unit rounding mode (TFPURoundingMode).]
GetRoundMode
[GetSSECSR |b Math:: Get MXCSR control word (Intel only) (DWord)]
GetSSECSR
[GradToDeg |b Math:: Convert grads angle to degrees angle (Float)]
GradToDeg(§|) {? grad: float}
[GradToRad |b Math:: Convert grads angle to radians angle (Float)]
GradToRad(§|) {? grad: float}
[Hypot |b Math:: Return hypotenuse of triangle (Float)]
Hypot(§|,) {? x: float; y: float}
[IfThen |b Math:: Return one of two values, depending on a boolean condition (Integer|Int64|Double)]
IfThen(§|,,) {? val: Boolean; const iftrue: Integer|Int64|Double; const iffalse: Integer|Int64|Double}
[InRange |b Math:: Check whether value is in range (Boolean).]
InRange(§|,,) {? const AValue: Integer; const AMin: Integer|Int64; const AMax: Integer|Int64}
[IntPower |b Math:: Return integer power (Float).]
IntPower(§|,) {? base: float; const exponent: Integer}
[IsInfinite |b Math:: Check whether value is infinite (Boolean)]
IsInfinite(§|) {? const d: Double}
[IsNan |b Math:: Check whether value is Not a Number (Boolean)]
IsNan(§|) {? const d: Double}
[IsZero |b Math:: Check whether value is zero (Boolean)]
IsZero(§|,) {? const A: Single|Extended; optional Epsilon: Single|Extended}
[LdExp |b Math:: Return (2 to the power p) times x (Float)]
LdExp(§|,) {? x: float; const p: Integer}
[Lnxp1 |b Math:: Return natural logarithm of 1+X (Float)]
Lnxp1(§|) {? x: float}
[Log10 |b Math:: Return 10-Based logarithm (Float).]
Log10(§|) {? x: float}
[Log2 |b Math:: Return 2-based logarithm (Float)]
Log2(§|) {? x: float}
[Logn |b Math:: Return N-based logarithm (Float).]
Logn(§|,) {? n: float; x: float}
[Max |b Math:: Return largest of 2 values (Integer|Cardinal|Int64|Extended)]
Max(§|,) {? a: Integer|Cardinal|Int64|Extended; b: Integer|Cardinal|Int64|Extended}
[MaxIntValue |b Math:: Return largest element in integer array (Integer)]
MaxIntValue(§|) {? const Data: Array[] of Integer}
[MaxValue |b Math:: Return largest value in array (Float|Integer)]
MaxValue(§|,) {? const data: Array[] of float|Array[] of integer|PFloat|PInteger; optional const N: Integer}
[Mean |b Math:: Return mean value of array (Float)]
Mean(§|,) {? const data: Array[] of float | PFloat; optional const N: Longint}
[MeanAndStdDev |b Math:: Return mean and standard deviation of array]
MeanAndStdDev(§|,,,) {? const data: Array[] of float|PFloat; optional const N: Longint; var mean: float; var stddev: float}
[Min |b Math:: Return smallest of two values (Integer|Cardinal|Int64|Extended).]
Min(§|,) {? a: Integer|Cardinal|Int64|Extended; b: Integer|Cardinal|Int64|Extended}
[MinIntValue |b Math:: Return smallest value in integer array (Integer)]
MinIntValue(§|) {? const Data: Array[] of Integer}
[MinValue |b Math:: Return smallest value in array (Float|Integer)]
MinValue(§|,) {? const data: Array[] of float|PFloat; optional const N: Integer}
[MomentSkewKurtosis |b Math:: Return 4 first moments of distribution (Float)]
MomentSkewKurtosis(§|,,,,,,,) {? const data: Array[] of float|PFloat; optional const N: Integer; var m1: float; var m2: float; var m3: float; var m4: float; var skew: float; var kurtosis: float}
[Norm |b Math:: Return Euclidian norm (Float)]
Norm(§|,) {? const data: Array[] of float|PFloat; optional const N: Integer}
[PopnStdDev |b Math:: Return population standard deviation (Float)]
PopnStdDev(§|,) {? const data: Array[] of float|PFloat; optional const N: Integer}
[PopnVariance |b Math:: Return population variance (Float)]
PopnVariance(§|,) {? const data: Array[] of float|PFloat; const N: Integer}
[Power |b Math:: Return real power (Float).]
Power(§|,) {? base: float; exponent: float}
[RadToCycle |b Math:: Convert radians angle to cycle angle (Float)]
RadToCycle(§|) {? rad: float}
[RadToDeg |b Math:: Convert radians angle to degrees angle (Float)]
RadToDeg(§|) {? rad: float}
[RadToGrad |b Math:: Convert radians angle to grads angle (Float)]
RadToGrad(§|) {? rad: float}
[Randg |b Math:: Return gaussian distributed random number (Float).]
Randg(§|,) {? mean: float; stddev: float}
[SameValue |b Math:: Check whether 2 float values are the same (Boolean)]
SameValue(§|,,) {? const A: Extended|Single; const B: Extended|Single; optional Epsilon: Extended|Single}
[SetExceptionMask |b Math:: Set the Floating Point Unit exception mask (TFPUExceptionMask).]
SetExceptionMask(§|) {? const Mask: TFPUExceptionMask}
[SetPrecisionMode |b Math:: Set the Floating Point Unit precision mode (TFPURoundingMode).]
SetPrecisionMode(§|) {? const Precision: TFPUPrecisionMode}
[SetRoundMode |b Math:: Set the Floating Point Unit rounding mode (TFPURoundingMode).]
SetRoundMode(§|) {? const RoundMode: TFPURoundingMode}
[SetSSECSR |b Math:: Set MXCSR control word (Intel only)]
SetSSECSR(§|) {? w: dword}
[Sign |b Math:: Return sign of argument (TValueSign)]
Sign(§|) {? const AValue: Integer|Int64|Double}
[SinCos |b Math:: Return sine and cosine of argument]
SinCos(§|,,) {? theta: float; var sinus: float; var cosinus: float}
[Sinh |b Math:: Return hyperbolic sine (Float)]
Sinh(§|) {? x: float}
[StdDev |b Math:: Return standard deviation of data (Float)]
Stddev(§|,) {? const data: Array[] of float|PFloat; optional const N: Integer}
[Sum |b Math:: Return sum of values (Float)]
Sum(§|,) {? const data: Array[] of float|PFloat; const N: LongInt}
[SumOfSquares |b Math:: Return sum of squares of values (Float)]
SumOfSquares(§|,) {? const data: Array[] of float|PFloat; const N: Integer}
[SumsAndSquares |b Math:: Return sum and sum of squares of values.]
SumsAndSquares(§|,,,) {? const data: Array[] of float|PFloat; optional const N: Integer; var sum: float; var sumofsquares: float}
[Tan |b Math:: Return tangent (Float)]
Tan(§|) {? x: float}
[Tanh |b Math:: Return hyperbolic tangent (Float)]
Tanh(§|) {? x: float}
[TotalVariance |b Math:: Return total varians of values (Float)]
TotalVariance(§|,) {? const data: Array[] of float|PFloat; const N: Integer}
[Variance |b Math:: Return variance of values (Float)]
Variance(§|,) {? const data: Array[] of Float| PFloat; optional const n: Integer}

;==============================================================================================
;   Unit: Dynlibs
;==============================================================================================

[NilHandle |r Dynlibs:: Correctly typed Nil handle - returned on error by LoadLibrary]
NilHandle

[HModule |p Dynlibs:: Alias for TLibHandle type.]
HModule
[TLibHandle |p Dynlibs:: Library handle type]
TLibHandle

[FreeLibrary |b Dynlibs:: For compatibility with Delphi/Windows: Unload a library (Boolean)]
FreeLibrary(§|) {? Lib: TLibHandle}
[GetProcAddress |b Dynlibs:: For compatibility with Delphi/Windows: Get the address of a procedure (Pointer)]
GetProcAddress(§|,) {? Lib: TLibHandle; ProcName: AnsiString}
[GetProcedureAddress |b Dynlibs:: Get the address of a procedure or symbol in a dynamic library (Pointer).]
GetProcedureAddress(§|,) {? Lib: TLibHandle; ProcName: AnsiString}
[LoadLibrary |b Dynlibs:: Load a dynamic library and return a handle to it (TLibHandle).]
LoadLibrary(§|) {? Name: AnsiString}
[UnloadLibrary |b Dynlibs:: Unload a previously loaded library (Boolean)]
UnloadLibrary(§|) {? Lib: TLibHandle}


;==============================================================================================
;   Unit: Strings
;==============================================================================================

[StrAlloc |b Strings:: Allocate memory for a new null-terminated string on the heap (PChar)]
StrAlloc(§|) {? L: SizeInt}
[StrCat |b Strings:: Concatenate 2 null-terminated strings (PChar).]
StrCat(§|,) {? dest: pchar; source: pchar}
[StrComp |b Strings:: Compare 2 null-terminated strings, case sensitive (SizeInt).]
StrComp(§|,) {? str1: pchar; str2: pchar}
[StrCopy |b Strings:: Copy a null-terminated string (PChar)]
StrCopy(§|,) {? dest: pchar; source: pchar}
[StrDispose |b Strings:: disposes of a null-terminated string on the heap (PChar)]
StrDispose(§|) {? p: pchar}
[StrECopy |b Strings:: Copy a null-terminated string, return a pointer to the end (PChar).]
StrECopy(§|,) {? dest: pchar; source: pchar}
[StrEnd |b Strings:: Return a pointer to the end of a null-terminated string (PChar)]
StrEnd(§|) {? p: pchar}
[StrIComp |b Strings:: Compare 2 null-terminated strings, case insensitive (SizeInt).]
StrIComp(§|,) {? str1: pchar; str2: pchar}
[StrLCat |b Strings:: Concatenate 2 null-terminated strings, with length boundary (PChar).]
StrLCat(§|,,) {? dest: pchar; source: pchar;l: SizeInt}
[StrLComp |b Strings:: Compare limited number of characters of 2 null-terminated strings (SizeInt)]
StrLComp(§|,,) {? str1: pchar; str2: pchar; l: SizeInt}
[StrLCopy |b Strings:: Copy a null-terminated string, limited in length (PChar).]
StrLCopy(§|,,) {? dest: pchar; source: pchar; maxlen: SizeInt}
[StrLen |b Strings:: Length of a null-terminated string (SizeInt).]
StrLen(§|) {? p: pchar}
[StrLIComp |b Strings:: Compare limited number of characters in 2 null-terminated strings, ignoring case (SizeInt).]
StrLIComp(§|,,) {? str1: pchar; str2: pchar; l: SizeInt}
[StrLower |b Strings:: Convert null-terminated string to all-lowercase (PChar).]
StrLower(§|) {? p: pchar}
[StrMove |b Strings:: Move a null-terminated string to new location (PChar).]
StrMove(§|,,) {? dest: pchar; source: pchar; l: SizeInt}
[StrNew |b Strings:: Allocate room for new null-terminated string (PChar).]
StrNew(§|) {? p: pchar}
[StrPas |b Strings:: Convert a null-terminated string to a shortstring (ShortString).]
StrPas(§|) {? p: pchar}
[StrPCopy |b Strings:: Copy a pascal string to a null-terminated string (PChar)]
StrPCopy(§|,) {? d: pchar; const s: String}
[StrPos |b Strings:: Search for a null-terminated substring in a null-terminated string (PChar)]
StrPos(§|,) {? str1: pchar; str2: pchar}
[StrRScan |b Strings:: Find last occurrence of a character in a null-terminated string (PChar).]
StrRScan(§|,) {? p: pchar; c: Char}
[StrScan |b Strings:: Find first occurrence of a character in a null-terminated string (PChar).]
StrScan(§|,) {? p: pchar; c: Char}
[StrUpper |b Strings:: Convert null-terminated string to all-uppercase (PChar)]
StrUpper(§|) {? p: pchar}

;==============================================================================================
;   Unit: Strutils
;==============================================================================================

[AnsiResemblesProc |r Strutils:: Procedural variable, called when checking 2 strings for resemblances in AnsiResemblesText]
AnsiResemblesProc
[Brackets |r Strutils:: Set of characters that contain all possible bracket characters]
Brackets
[DigitChars |r Strutils:: Set of digit characters]
DigitChars
[StdSwitchChars |r Strutils:: Standard characters for the SwitchChars argument of GetCmdLineArg.]
StdSwitchChars
[StdWordDelims |r Strutils:: Standard word delimiter values.]
StdWordDelims
[WordDelimiters |r Strutils:: Standard word delimiters]
WordDelimiters

[TCompareTextProc |p Strutils:: Function prototype for comparing two string in AnsiResemblesText]
TCompareTextProc
[TSoundexIntLength |p Strutils:: Range of allowed integer soundex lengths.]
TSoundexIntLength
[TSoundexLength |p Strutils:: Range of allowed soundex lengths.]
TSoundexLength
[TStringSeachOption |p Strutils:: Possible options for SearchBuf call.]
TStringSeachOption
[TStringSearchOption |p Strutils:: Possible options for SearchBuf call.]
TStringSearchOption
[TStringSearchOptions |p Strutils:: Set of options for SearchBuf call.]
TStringSearchOptions

[AddChar |b Strutils:: Add characters to the left of a string till a certain length (String)]
AddChar(§|,,) {? C: Char; const S: String; N: Integer}
[AddCharR |b Strutils:: Add chars at the end of a string till it reaches a certain length (String)]
AddCharR(§|,,) {? C: Char; const S: String; N: Integer}
[AnsiContainsStr |b Strutils:: Checks whether a string contains a given substring (Boolean)]
AnsiContainsStr(§|,) {? const AText: String; const ASubText: String}
[AnsiContainsText |b Strutils:: Check whether a string contains a certain substring, ignoring case (Boolean).]
AnsiContainsText(§|,) {? const AText: String; const ASubText: String}
[AnsiEndsStr |b Strutils:: Check whether a string ends with a certain substring (Boolean)]
AnsiEndsStr(§|,) {? const ASubText: String; const AText: String}
[AnsiEndsText |b Strutils:: Check whether a string ends with a certain substring, ignoring case (Boolean).]
AnsiEndsText(§|,) {? const ASubText: String; const AText: String}
[AnsiIndexStr |b Strutils:: Searches, observing case, for a string in an array of strings (Integer).]
AnsiIndexStr(§|,) {? const AText: String; const AValues: Array[] of String}
[AnsiIndexText |b Strutils:: Searches, case insensitive, for a string in an array of strings (Integer).]
AnsiIndexText(§|,) {? const AText: String; const AValues: Array[] of String}
[AnsiLeftStr |b Strutils:: Copies a number of characters starting at the left of a string (AnsiString)]
AnsiLeftStr(§|,) {? const AText: AnsiString; const ACount: Integer}
[AnsiMatchStr |b Strutils:: Check whether a string occurs in an array of strings, observing case (Boolean).]
AnsiMatchStr(§|,) {? const AText: String; const AValues: Array[] of String}
[AnsiMatchText |b Strutils:: Check whether a string occurs in an array of strings, disregarding case (Boolean).]
AnsiMatchText(§|,) {? const AText: String; const AValues: Array[] of String}
[AnsiMidStr |b Strutils:: Returns a number of characters copied from a given location in a string (AnsiString)]
AnsiMidStr(§|,,) {? const AText: AnsiString; const AStart: Integer; const ACount: Integer}
[AnsiProperCase |b Strutils:: Pretty-Print a string: make lowercase and capitalize first letters of words (String)]
AnsiProperCase(§|,) {? const S: String; const WordDelims: TSysCharSet}
[AnsiReplaceStr |b Strutils:: Search and replace all occurrences of a string, case sensitive (String).]
AnsiReplaceStr(§|,,) {? const AText: String; const AFromText: String; const AToText: String}
[AnsiReplaceText |b Strutils:: Search and replace all occurrences of a string, case sensitive (String).]
AnsiReplaceText(§|,,) {? const AText: String; const AFromText: String; const AToText: String}
[AnsiResemblesText |b Strutils:: Check whether 2 strings resemble each other (Boolean).]
AnsiResemblesText(§|,) {? const AText: String; const AOther: String}
[AnsiReverseString |b Strutils:: Reverse the letters in a string (AnsiString).]
AnsiReverseString(§|) {? const AText: AnsiString}
[AnsiRightStr |b Strutils:: Copies a number of characters starting at the right of a string (AnsiString)]
AnsiRightStr(§|,) {? const AText: AnsiString; const ACount: Integer}
[AnsiStartsStr |b Strutils:: Check whether a string starts with a given substring, observing case (Boolean)]
AnsiStartsStr(§|,) {? const ASubText: String; const AText: String}
[AnsiStartsText |b Strutils:: Check whether a string starts with a given substring, ignoring case (Boolean)]
AnsiStartsText(§|,) {? const ASubText: String; const AText: String}
[BinToHex |b Strutils:: Convert a binary buffer to a hexadecimal string]
BinToHex(§|,,) {? BinValue: PChar; HexValue: PChar; BinBufSize: Integer}
[Copy2Space |b Strutils:: Returns all characters in a string till the first space character (not included) (String).]
Copy2Space(§|) {? const S: String}
[Copy2SpaceDel |b Strutils:: Deletes and returns all characters in a string till the first space character (not included) (String).]
Copy2SpaceDel(§|) {? var S: String}
[Copy2Symb |b Strutils:: Returns all characters in a string till a given character (not included) (String).]
Copy2Symb(§|,) {? const S: String; Symb: Char}
[Copy2SymbDel |b Strutils:: Deletes and returns all characters in a string till a given character (not included) (String).]
Copy2SymbDel(§|,) {? var S: String; Symb: Char}
[Dec2Numb |b Strutils:: Convert a decimal number to a string representation, using given a base (String).]
Dec2Numb(§|,,) {? N: LongInt; Len: Byte; Base: Byte}
[DecodeSoundexInt |b Strutils:: Decodes the integer representation of a soundex code and returns the original soundex code (String).]
DecodeSoundexInt(§|) {? AValue: Integer}
[DecodeSoundexWord |b Strutils:: Decodes the word-sized representation of a soundex code and returns the original soundex code (String).]
DecodeSoundexWord(§|) {? AValue: Word}
[DelChars |b Strutils:: Delete all occurrences of a given character from a string (String).]
DelChars(§|) {? const S: String; Chr: Char}
[DelSpace |b Strutils:: Delete all occurrences of a space from a string (String).]
DelSpace(§|) {? const S: String}
[DelSpace1 |b Strutils:: Reduces sequences of space characters to 1 space character (String).]
DelSpace1(§|) {? const S: String}
[DupeString |b Strutils:: Creates and concatenates N copies of a string (String)]
DupeString(§|,) {? const AText: String; ACount: Integer}
[ExtractDelimited |b Strutils:: Extract the N-th delimited part from a string (String).]
ExtractDelimited(§|,,) {? N: Integer; const S: String; const Delims: TSysCharSet}
[ExtractSubstr |b Strutils:: Extract a word from a string, starting at a given position in the string (String).]
ExtractSubstr(§|,,) {? const S: String; var Pos: Integer; const Delims: TSysCharSet}
[ExtractWord |b Strutils:: Extract the N-th word out of a string (String).]
ExtractWord(§|,,) {? N: Integer; const S: String; const WordDelims: TSysCharSet}
[ExtractWordPos |b Strutils:: Extract a word from a string, and return the position where it was located in the string (String).]
ExtractWordPos(§|,) {? N: Integer; const S: String; const WordDelims: TSysCharSet; var Pos: Integer}
[FindPart |b Strutils:: Search for a substring in a string, using wildcards (Integer).]
FindPart(§|,) {? const HelpWilds: String; const InputStr: String}
[GetCmdLineArg |b Strutils:: Returns the command-line argument following the given switch (String).]
GetCmdLineArg(§|,) {? const Switch: String; SwitchChars: TSysCharSet}
[Hex2Dec |b Strutils:: Converts a hexadecimal string to a decimal value (LongInt)]
Hex2Dec(§|) {? const S: String}
[HexToBin |b Strutils:: Convert a hexadecimal string to a binary buffer (Integer)]
HexToBin(§|,,) {? HexValue: PChar; BinValue: PChar; BinBufSize: Integer}
[IfThen |b Strutils:: Returns one of two strings, depending on a boolean expression (String)]
IfThen(§|,,) {? AValue: Boolean; const ATrue: String; optional AFalse: String}
[IntToBin |b Strutils:: Converts an integer to a binary string representation, inserting spaces at fixed locations (String).]
IntToBin(§|,,) {? Value: LongInt; Digits: Integer; Spaces: Integer}
[IntToRoman |b Strutils:: Represent an integer with roman numerals (String)]
IntToRoman(§|) {? Value: LongInt}
[IsEmptyStr |b Strutils:: Check whether a string is empty, disregaring whitespace characters (Boolean)]
IsEmptyStr(§|,,) {? const S: String; const EmptyChars: TSysCharSet}
[IsWild |b Strutils:: Check whether a string matches a wildcard search expression (Boolean).]
IsWild(§|,,) {? InputStr: String; Wilds: String; IgnoreCase: Boolean}
[IsWordPresent |b Strutils:: Check for the presence of a word in a string (Boolean).]
IsWordPresent(§|,,) {? const W: String; const S: String; const WordDelims: TSysCharSet}
[LeftBStr |b Strutils:: Copies Count characters starting at the left of a string (AnsiString).]
LeftBStr(§|,) {? const AText: AnsiString; const AByteCount: Integer}
[LeftStr |b Strutils:: Copies Count characters starting at the left of a string (AnsiString|WideString).]
LeftStr(§|,) {? const AText: AnsiString|WideString; const ACount: Integer}
[MidBStr |b Strutils:: Copies a number of characters starting at a given position in a string (AnsiString).]
MidBStr(§|,,) {? const AText: AnsiString; const AByteStart: Integer; const AByteCount: Integer}
[MidStr |b Strutils:: Copies a number of characters starting at a given position in a string (AnsiString|WideString).]
MidStr(§|,,) {? const AText: AnsiString|WideString; const AStart: Integer; const ACount: Integer}
[NPos |b Strutils:: Returns the position of the N-th occurence of a substring in a string (Integer).]
NPos(§|,,) {? const C: String; S: String; N: Integer}
[Numb2Dec |b Strutils:: Converts a string representation of a number to its numerical value, given a certain base (LongInt).]
Numb2Dec(§|,) {? S: String; Base: Byte}
[Numb2USA |b Strutils:: Insert thousand separators (String).]
Numb2USA(§|) {? const S: String}
[PadCenter |b Strutils:: Pad the string to a certain length, so the string is centered (String).]
PadCenter(§|,) {? const S: String; Len: Integer}
[PadLeft |b Strutils:: Add spaces to the left of a string till a certain length is reached (String).]
PadLeft(§|,) {? const S: String; N: Integer}
[PadRight |b Strutils:: Add spaces to the right of a string till a certain length is reached (String).]
PadRight(§|,) {? const S: String; N: Integer}
[PosEx |b Strutils:: Search for the occurance of a character in a string, starting at a certain position (Integer).]
PosEx(§|,,) {? const SubStr: String|Char; const S: String; optional Offset: Cardinal);
[RandomFrom |b Strutils:: Choose a random string from an array of strings (String).]
RandomFrom(§|) {? const AValues: Array[] of String}
[ReverseString |b Strutils:: Reverse characters in a string (String)]
ReverseString(§|) {? const AText: String}
[RightBStr |b Strutils:: Copy a given number of characters (bytes), counting from the right of a string (AnsiString).]
RightBStr(§|,) {? const AText: AnsiString; const AByteCount: Integer}
[RightStr |b Strutils:: Copy a given number of characters, counting from the right of a string (AnsiString|Widestring).]
RightStr(§|,) {? const AText: AnsiString|WideString; const ACount: Integer}
[RomanToInt |b Strutils:: Convert a string with a Roman number to it's decimal value (LongInt).]
RomanToInt(§|) {? const S: String}
[RPos |b Strutils:: Find last occurrence of substring or character in a string (Integer)]
RPos(§|,) {? c: Char|Ansistring; const S: AnsiString}
[RPosex |b Strutils:: Find last occurrence substring or character in a string, starting at a certain position (Integer)]
RPosEX(§|,,) {? C: Char|Ansistring; const S: AnsiString; offs: cardinal}
[SearchBuf |b Strutils:: Search a buffer for a certain string (PChar).]
SearchBuf(§|,,,,,) {? Buf: PChar; BufLen: Integer; SelStart: Integer; SelLength: Integer; SearchString: String; optional Options: TStringSearchOptions}
[Soundex |b Strutils:: Compute the soundex of a string (String)]
Soundex(§|,) {? const AText: String; optional ALength: TSoundexLength}
[SoundexCompare |b Strutils:: Compare soundex values of 2 strings (Integer).]
SoundexCompare(§|,,) {? const AText: String; const AOther: String; optional ALength: TSoundexLength}
[SoundexInt |b Strutils:: Soundex value as an integer (Integer).]
SoundexInt(§|,) {? const AText: String; optional ALength: TSoundexIntLength}
[SoundexProc |b Strutils:: Default AnsiResemblesText implementation (Boolean).]
SoundexProc(§|,) {? const AText: String; const AOther: String}
[SoundexSimilar |b Strutils:: Check whether 2 strings have equal soundex values (Boolean)]
SoundexSimilar(§|,,) {? const AText: String; const AOther: String; optional ALength: TSoundexLength}
[SoundexWord |b Strutils:: Calculate a word-sized soundex value (Word)]
SoundexWord(§|) {? const AText: String}
[StuffString |b Strutils:: Replace part of a string with another string (String).]
StuffString(§|,,,) {? const AText: String; AStart: Cardinal; ALength: Cardinal; const ASubText: String}
[Tab2Space |b Strutils:: Convert tab characters to a number of spaces (String)]
Tab2Space(§|,) {? const S: String; Numb: Byte}
[WordCount |b Strutils:: Count the number of words in a string (Integer).]
WordCount(§|,) {? const S: String; const WordDelims: TSysCharSet}
[WordPosition |b Strutils:: Search position of Nth word in a string (Integer).]
WordPosition(§|,,) {? const N: Integer; const S: String; const WordDelims: TSysCharSet}
[XorDecode |b Strutils:: Decode a string encoded with XorEncode (String)]
XorDecode(§|,) {? const Key: String; const Source: String}
[XorEncode |b Strutils:: Encode a string by XOR-ing its characters using characters of a given key, representing the result as hex values (String).]
XorEncode(§|,) {? const Key: String; const Source: String}
[XorString |b Strutils:: Encode a string by XOR-ing its characters using characters of a given key (ShortString).]
XorString(§|,) {? const Key: ShortString; const Src: ShortString}

;==============================================================================================
;   Unit: Objpas
;==============================================================================================

[MaxInt |r Objpas:: Maximum value for Integer type.]
MaxInt

[Integer |p Objpas:: Redefinition of integer as 32-bit type.]
Integer
[IntegerArray |p Objpas:: Generic array of integer]
IntegerArray
[PInteger |p Objpas:: Pointer to Integer type.]
PInteger
[PIntegerArray |p Objpas:: Pointer to TIntegerArray type.]
PIntegerArray
[PointerArray |p Objpas:: Generic Array of pointers.]
PointerArray
[PPointerArray |p Objpas:: Pointer to PointerArray]
PPointerArray
[PResStringRec |p Objpas:: Pointer to ansistring (Delphi compatibility).]
PResStringRec
[PString |p Objpas:: Pointer to ansistring type.]
PString
[TBoundArray |p Objpas:: Array of integer, used in interfaces.]
TBoundArray
[TIntegerArray |p Objpas:: Alias for IntegerArray]
TIntegerArray
[TPointerArray |p Objpas:: Alias for PointerArray]
TPointerArray
[TResourceIterator |p Objpas:: Enumeration callback type for resource strings]
TResourceIterator
[TResStringRec |p Objpas:: Ansistring record in resource table (Delphi compatibility).]
TResStringRec

[AssignFile |b Objpas:: Assign text or untyped file]
AssignFile(§|,) {? var f: File|Text|TypedFile; const Name: String|PChar|Char}
[CloseFile |b Objpas:: Close text or untyped file ]
CloseFile(§|) {? var f: File|Text}
[GetResourceStringCurrentValue |b Objpas:: Return current value of resourcestring (AnsiString)]
GetResourceStringCurrentValue(§|,) {? TableIndex: LongInt; StringIndex: LongInt}
[GetResourceStringDefaultValue |b Objpas:: Return default (original) value of resourcestring (AnsiString)]
GetResourceStringDefaultValue(§|,) {? TableIndex: LongInt; StringIndex: LongInt}
[GetResourceStringHash |b Objpas:: Return hash value of resource string (LongInt)]
GetResourceStringHash(§|,) {? TableIndex: LongInt; StringIndex: LongInt}
[GetResourceStringName |b Objpas:: Return name of resource string (AnsiString).]
GetResourceStringName(§|,) {? TableIndex: LongInt; StringIndex: LongInt}
[Hash |b Objpas:: Create GNU Gettext hash value for a string (Longint)]
Hash(§|) {? S: AnsiString}
[LoadResString |b Objpas:: Load resource string (AnsiString)]
LoadResString(§|) {? p: PResStringRec}
[ParamStr |b Objpas:: Return command-line parameter (AnsiString)]
ParamStr(§|) {? Param: Integer}
[ResetResourceTables |b Objpas:: Restore all resource strings to their declared values} 
ResetResourceTables
[ResourceStringCount |b Objpas:: Return number of resource strins in table (Longint)]
ResourceStringCount(§|) {? TableIndex: LongInt}
[ResourceStringTableCount |b Objpas:: Return number of resource string tables (Longint)]
ResourceStringTableCount
[SetResourceStrings |b Objpas:: Set values of all resource strings.]
SetResourceStrings(§|) {? SetFunction: TResourceIterator}
[SetResourceStringValue |b Objpas:: Set value of a resource string (Boolean)]
SetResourceStringValue(§|,,) {? TableIndex: LongInt; StringIndex: LongInt; Value: Ansistring}

;==============================================================================================
;   Unit: Typinfo
;==============================================================================================

[EPropertyError |g Typinfo:: Exception raised in case of an error in one of the functions.]
EPropertyError

[BooleanIdents |r Typinfo:: Names for boolean values]
BooleanIdents
[DotSep |r Typinfo:: Name separator character]
DotSep
[OnGetPropValue |r Typinfo:: Callback to get a property value as a variant.]
OnGetPropValue
[OnGetVariantprop |r Typinfo:: Callback to get a variant property value.]
OnGetVariantprop
[OnSetPropValue |r Typinfo:: Callback to set a property value as a variant.]
OnSetPropValue
[OnSetVariantprop |r Typinfo:: Callback to set a variant property value.]
OnSetVariantprop
[ptConst |r Typinfo:: Constant used in acces method]
ptConst
[ptField |r Typinfo:: Property acces directly from field]
ptField
[ptStatic |r Typinfo:: Property acces via static method]
ptStatic
[ptVirtual |r Typinfo:: Property acces via virtual method]
ptVirtual
[tkAny |r Typinfo:: Any property type]
tkAny
[tkMethods |r Typinfo:: Only method properties. (event handlers)]
tkMethods
[tkProperties |r Typinfo:: Real properties. (not methods)]
tkProperties
[tkString |r Typinfo:: Alias for the tsSString enumeration value]
tkString

[PPropInfo |p Typinfo:: Pointer to TPropInfo record]
PPropInfo
[PPropList |p Typinfo:: Pointer to TPropList]
PPropList
[PPTypeInfo |p Typinfo:: Pointer to PTypeInfo pointer]
PPTypeInfo
[PTypeData |p Typinfo:: Pointer to TTypeData record.]
PTypeData
[PTypeInfo |p Typinfo:: Pointer to TTypeInfo record]
PTypeInfo
[TFloatType |p Typinfo:: The size of a float type.]
TFloatType
[TGetPropValue |p Typinfo:: Callback type for the OnGetPropValue callback event]
TGetPropValue
[TGetVariantProp |p Typinfo:: Callback type for the OnGetVariantProp callback event]
TGetVariantProp
[TIntfFlag |p Typinfo:: Type of interface.]
TIntfFlag
[TIntfFlags |p Typinfo:: Set of TIntfFlag.]
TIntfFlags
[TIntfFlagsBase |p Typinfo:: Set of TIntfFlag.]
TIntfFlagsBase
[TMethodKind |p Typinfo:: Method type description]
TMethodKind
[TOrdType |p Typinfo:: Alias for TTordType.]
TOrdType
[TParamFlags |p Typinfo:: The kind of parameter for a method]
TParamFlags
[TProcInfoProc |p Typinfo:: Property info callback method]
TProcInfoProc
[TPropData |p Typinfo:: Property data record]
TPropData
[TPropInfo |p Typinfo:: Record describing one published property of a class]
TPropInfo
[TPropList |p Typinfo:: Array of property information pointers]
TPropList
[TSetPropValue |p Typinfo:: Callback type for the OnSetPropValue callback event]
TSetPropValue
[TSetVariantProp |p Typinfo:: Callback type for the OnSetVariantProp callback event]
TSetVariantProp
[TTypeData |p Typinfo:: Class properties type data record.]
TTypeData
[TTypeInfo |p Typinfo:: Type information record]
TTypeInfo
[TTypeKind |p Typinfo:: Type of a property.]
TTypeKind
[TTypeKinds |p Typinfo:: Set of TTypeKind enumeration.]
TTypeKinds
[Variant |p Typinfo:: Dummy type. Do not use.]
Variant

[FindPropInfo |b Typinfo:: Return property information by property name (PPropInfo).]
function FindPropInfo(§|,) {? Instance: TObject|TClass; const PropName: String}
[GetEnumName |b Typinfo:: Return name of enumeration constant (String).]
GetEnumName(§|,) {? TypeInfo: PTypeInfo; Value: Integer}
[GetEnumProp |b Typinfo:: Return the value of an enumeration type property (String).]
GetEnumProp(§|,) {? Instance: TObject; const Prop: String|PPropInfo}
[GetEnumValue |b Typinfo:: Get ordinal value for enumerated type by name (Integer)]
GetEnumValue(§|,) {? TypeInfo: PTypeInfo; const Name: String}
[GetFloatProp |b Typinfo:: Return value of floating point property (Extended)]
GetFloatProp(§|,) {? Instance: TObject; const PropName: String|PPropInfo)
[GetInt64Prop |b Typinfo:: return value of an Int64 property (Int64)]
GetInt64Prop(§|,) {? Instance: TObject; const Prop: String|PPropInfo}
[GetMethodProp |b Typinfo:: Return value of a method property (TMethod)]
GetMethodProp(§|,) {? Instance: TObject; const Prop: String|PPropInfo}
[GetObjectProp |b Typinfo:: Return value of an object-type property (TObject).]
GetObjectProp(§|,,) {? Instance: TObject; const Prop: String|PPropInfo; optional MinClass: TClass}
[GetObjectPropClass |b Typinfo:: Return class of property (TClass).]
GetObjectPropClass(§|,) {? Instance: TObject; const PropName: String}
[GetOrdProp |b Typinfo:: Get the value of an ordinal property (Int64)]
GetOrdProp(§|,) {? Instance: TObject; const Prop: String|PPropInfo}
[GetPropInfo |b Typinfo:: Return property type information, by property name (PPropInfo).]
GetPropInfo(§|,) {? TypeInfo: PTypeInfo|TObject|TClass; const PropName: String}
[GetPropInfos |b Typinfo:: Return a list of published properties.]
GetPropInfos(§|,) {? TypeInfo: PTypeInfo; PropList: PPropList}
[GetPropList |b Typinfo:: Return a list of a certain type of published properties (LongInt|SizeInt).]
GetPropList(§|,,,) {? TypeInfo: PTypeInfo; optional TypeKinds: TTypeKinds; PropList: PPropList; optional Sorted: Boolean}
[GetPropValue |b Typinfo:: Get property value as a string (Variant).]
GetPropValue(§|,,) {? Instance: TObject; const PropName: String; optional PreferStrings: Boolean}
[GetSetProp |b Typinfo:: Return the value of a set property (String).]
GetSetProp(§|,,) {? Instance: TObject; const Prop: String|PPropInfo; optional Brackets: Boolean}
[GetStrProp |b Typinfo:: Return the value of a string property (String|AnsiString).]
GetStrProp(§|,) {? Instance: TObject; const PropName: String|PPropInfo}
[GetTypeData |b Typinfo:: Return a pointer to type data, based on type information (PTypeData).]
GetTypeData(§|) {? TypeInfo: PTypeInfo}
[GetVariantProp |b Typinfo:: Return the value of a variant property (Variant).]
GetVariantProp(§|,) {? Instance: TObject; const PropName: String|PPropInfo}
[IsPublishedProp |b Typinfo:: Check whether a published property exists (Boolean).]
IsPublishedProp(§|,) {? Instance: TObject|TClass; const PropName: String}
[IsStoredProp |b Typinfo:: Check whether a property is stored (Boolean).]
IsStoredProp(§|,) {? Instance: TObject; const Prop: String|PPropInfo}
[PropIsType |b Typinfo:: Check the type of a published property (Boolean).]
PropIsType(§|,,) {? Instance: TObject|TClass; const PropName: String; TypeKind: TTypeKind}
[PropType |b Typinfo:: Return the type of a property (TTypeKind)]
PropType(§|,) {? Instance: TObject|TClass; const PropName: String}
[SetEnumProp |b Typinfo:: Set value of an enumerated-type property]
SetEnumProp(§|,,) {? Instance: TObject; const Prop: String|PPropInfo; const Value: String}
[SetFloatProp |b Typinfo:: Set value of a float property.]
SetFloatProp(§|,,) {? Instance: TObject; const Prop: String|PPropInfo; Value: Extended}
[SetInt64Prop |b Typinfo:: Set value of a Int64 property]
SetInt64Prop(§|,,) {? Instance: TObject; const Prop: String|PPropInfo; const Value: Int64}
[SetMethodProp |b Typinfo:: Set the value of a method property]
SetMethodProp(§|,,) {? Instance: TObject; const Prop: String|PPropInfo; const Value: TMethod}
[SetObjectProp |b Typinfo:: Set the value of an object-type property.]
SetObjectProp(§|,,) {? Instance: TObject; const Prop: String|PPropInfo; Value: TObject}
[SetOrdProp |b Typinfo:: Set value of an ordinal property]
SetOrdProp(§|,,) {? Instance: TObject; const Prop: String|PPropInfo; Value: Int64}
[SetPropValue |b Typinfo:: Set property value as variant]
SetPropValue(§|,,) {? Instance: TObject; const PropName: String; const Value: Variant}
[SetSetProp |b Typinfo:: Set value of set-typed property.]
SetSetProp(§|,,) {? Instance: TObject; const Prop: String|PPropInfo; const Value: String}
[SetStrProp |b Typinfo:: Set value of a string property]
SetStrProp(§|,,) {? Instance: TObject; const Prop: String|PPropInfo; const Value: AnsiString}
[SetToString |b Typinfo:: Convert set to a string description (String)]
SetToString(§|,,) {? PropInfo: PPropInfo; Value: Integer; optional Brackets: Boolean}
[SetVariantProp |b Typinfo:: Set value of a variant property]
SetVariantProp(§|,,) {? Instance: TObject; const Prop: String|PPropInfo; const Value: Variant}
[StringToSet |b Typinfo:: Convert string description to a set (Integer).]
StringToSet(§|,) {? PropInfo: PPropInfo; const Value: String}

;==============================================================================================
;   Unit: Classes
;==============================================================================================

[BitShift |r Classes:: Used to calculate the size of a bits array]
BitShift
[FilerSignature |r Classes:: Constant that is found at the start of a binary stream containing a streamed component. ]
FilerSignature
[fmCreate |r Classes:: TFileStream.Create creates a new file if needed. ]
fmCreate
[fmOpenRead |r Classes:: TFileStream.Create opens a file with read-only access. ]
fmOpenRead
[fmOpenReadWrite |r Classes:: TFileStream.Create opens a file with read-write access. ]
fmOpenReadWrite
[fmOpenWrite |r Classes:: TFileStream.Create opens a file with write-only access. ]
fmOpenWrite
[Mask |r Classes:: Bitmask with all bits on.]
Mask
[MaxBitFlags |r Classes:: Maximum number of bits in TBits collection.]
MaxBitFlags
[MaxBitRec |r Classes:: Maximum number of bit records in TBits.]
MaxBitRec
[MaxListSize |r Classes:: Maximum number of elemens in list. ]
MaxListSize
[scAlt |r Classes:: Indicates ALT key in a keyboard shortcut. ]
scAlt
[scCtrl |r Classes:: indicates CTRL key in a keyboard shortcut. ]
scCtrl
[scNone |r Classes:: Indicates no special key is presed in a keyboard shortcut. ]
scNone
[scShift |r Classes:: Indicates Shift key in a keyboard shortcut. ]
scShift
[soFromBeginning |r Classes:: Seek starts relative to the stream origin. ]
soFromBeginning
[soFromCurrent |r Classes:: Seek starts relative to the current position in the stream. ]
soFromCurrent
[soFromEnd |r Classes:: Seek starts relative to the stream end. ]
soFromEnd
[toEOF |r Classes:: Value returned by TParser.Token when the end of the input stream was reached. ]
toEOF
[toFloat |r Classes:: Value returned by TParser.Token when a floating point value was found in the input stream. ]
toFloat
[toInteger |r Classes:: Value returned by TParser.Token when an integer was found in the input stream. ]
toInteger
[toString |r Classes:: Value returned by TParser.Token when a string was found in the input stream. ]
toString
[toSymbol |r Classes:: Value returned by TParser.Token when a symbol was found in the input stream. ]
toSymbol


[HModule |p Classes:: Special type for handling modules.]
HModule
[HRsrc |p Classes:: Type to manage resources]
HRsrc
[PPointerList |p Classes:: Pointer to an array of pointers.]
PPointerList
[PStringItem |p Classes:: Pointer to a TStringItem record. ]
PStringItem
[PStringItemList |p Classes:: Pointer to a TStringItemList.]
PStringItemList
[TActiveXRegType |p Classes:: Used when registering ActveX component types.]
TActiveXRegType
[TAlignment |p Classes:: Type to specify text alignment in controls that display text.]
TAlignment
[TAncestorNotFoundEvent |p Classes:: This event occurs when an ancestor component cannot be found.]
TAncestorNotFoundEvent
[TBasicActionClass |p Classes:: TBasicAction class reference.]
TBasicActionClass
[TBasicActionLinkClass |p Classes:: TBasicActionLink class reference.]
TBasicActionLinkClass
[TBitArray |p Classes:: Array to store bits.]
TBitArray
[TCollectionItemClass |p Classes:: Class reference for TCollectionItem.]
TCollectionItemClass
[TCollectionNotification |p Classes:: Collection change notifcation enumeration.]
TCollectionNotification
[TComponentClass |p Classes:: Class of TComponent]
TComponentClass
[TComponentName |p Classes:: Special type for component names.]
TComponentName
[TComponentState |p Classes:: Indicates the state of the component during the streaming process.]
TComponentState
[TComponentStyle |p Classes:: Describes the style of the component.]
TComponentStyle
[TCreateComponentEvent |p Classes:: Event handler type, occurs when a component instance must be created when a component is read from a stream.]
TCreateComponentEvent
[TDuplicates |p Classes:: Type to describe what to do with duplicate values in a TStringlist.]
TDuplicates
[TFilerFlag |p Classes:: Flags used by the TFiler class]
TFilerFlag
[TFilerFlags |p Classes:: Set of TFilerFlag]
TFilerFlags
[TFindAncestorEvent |p Classes:: Event that occurs w]
TFindAncestorEvent
[TFindComponentClassEvent |p Classes:: Event handler type, occurs when a component class pointer must be found when reading a component from a stream.]
TFindComponentClassEvent
[TFindGlobalComponent |p Classes:: Callback type to search for a component.]
TFindGlobalComponent
[TFindMethodEvent |p Classes:: Occurs when the streaming process needs to locate a method]
TFindMethodEvent
[TGetChildProc |p Classes:: Callback used when obtaining child components.]
TGetChildProc
[TGetStrProc |p Classes:: Event for retrieving string values. ]
TGetStrProc
[THandle |p Classes:: Type to manage streams.]
THandle
[THelpContext |p Classes:: Range type to specify help contexts.]
THelpContext
[THelpEvent |p Classes:: Special event for display of online help. ]
THelpEvent
[THelpType |p Classes:: Enumeration type specifying the kind of help requested.]
THelpType
[TIdentMapEntry |p Classes:: Record used when associating names with integer values.]
TIdentMapEntry
[TIdentToInt |p Classes:: Callback for converting identifiers to integers.]
TIdentToInt
[TInitComponentHandler |p Classes:: Callback type for RegisterInitComponentHandler]
TInitComponentHandler
[TIntToIdent |p Classes:: Callback for converting integers to identifiers.]
TIntToIdent
[TListNotification |p Classes:: Kind of list notification event.]
TListNotification
[TListSortCompare |p Classes:: Callback type for the list sort algorithm.]
TListSortCompare
[TNotifyEvent |p Classes:: Standard event handler type. ]
TNotifyEvent
[TOperation |p Classes:: Operation of which a component is notified.]
TOperation
[TPersistentClass |p Classes:: Class reference type for TPersistent.]
TPersistentClass
[TPoint |p Classes:: Special type to handle a fake TComponent position]
TPoint
[TPointerList |p Classes:: Type for an Array of pointers.]
TPointerList
[TPropertyNotFoundEvent |p Classes:: Callback for the TReader.OnPropertyNotFound event.]
TPropertyNotFoundEvent
[TReadComponentsProc |p Classes:: Callback type when reading a component from a stream]
TReadComponentsProc
[TReaderError |p Classes:: Event handler type, called when an error occurs during the streaming.]
TReaderError
[TReaderProc |p Classes:: Reader procedure used by DefineProperties]
TReaderProc
[TReadWriteStringPropertyEvent |p Classes:: Callback for the TReader.OnReadStringProperty event handler]
TReadWriteStringPropertyEvent
[TRect |p Classes:: Descibes a rectangle]
TRect
[TReferenceNameEvent |p Classes:: Occurs when a named object needs to be looked up.]
TReferenceNameEvent
[TSeekOrigin |p Classes:: Specifies the origin of the TStream.Seek method.]
TSeekOrigin
[TSetMethodPropertyEvent |p Classes:: Callback for the TReader.OnSetMethodProperty event.]
TSetMethodPropertyEvent
[TSetNameEvent |p Classes:: Occurs when the reader needs to set a component's name.]
TSetNameEvent
[TShiftState |p Classes:: Indicates what special keys were pressed in combination with a normal key ]
TShiftState
[TShiftStateEnum |p Classes:: Keyboard/Mouse shift state enumerator]
TShiftStateEnum
[TShortCut |p Classes:: Enumeration type to identify shortcut key combinations.]
TShortCut
[TSmallPoint |p Classes:: Type to describe point in a small plane.]
TSmallPoint
[TStreamProc |p Classes:: Procedure type used in streaming.]
TStreamProc
[TStringItem |p Classes:: The TStringItem is used to store the string and object items in a TStringList string list instance. It should never be used directly. ]
TStringItem
[TStringItemList |p Classes:: Array of TStringItem records.]
TStringItemList
[TStringListSortCompare |p Classes:: Callback type used in stringlist compares.]
TStringListSortCompare
[TSynchronizeProcVar |p Classes:: Synchronize callback type]
TSynchronizeProcVar
[TThreadMethod |p Classes:: Procedure variable used when synchronizing threads.]
TThreadMethod
[TThreadPriority |p Classes:: Enumeration specifying the priority at which a thread runs.]
TThreadPriority
[TValueType |p Classes:: Enumerated type used to identify the kind of streamed property]
TValueType
[TWriteMethodPropertyEvent |p Classes:: Callback for the TWriter.OnWriteMethodProperty event.]
TWriteMethodPropertyEvent
[TWriterProc |p Classes:: Writer procedure used by DefineProperties]
TWriterProc

[EBitsError |g Classes:: Exception raised when an error occurs in a method of TBits. ]
EBitsError
[EClassNotFound |g Classes:: Exception raised when an unknown class is referenced in a streamed component. ]
EClassNotFound
[EComponentError |g Classes:: Exception raised when an error occurs in the component registration routines. ]
EComponentError
[EFCreateError |g Classes:: Exception raised when an error occurred during creation of a TFileStream stream. ]
EFCreateError
[EFilerError |g Classes:: Exception raised by the component streaming system if an error occurs. ]
EFilerError
[EFOpenError |g Classes:: Exception raised when an error occurred during creation of a TFileStream]
EFOpenError
[EInvalidImage |g Classes:: Exception raised when the resource header needed for streaming of a component is invalid. ]
EInvalidImage
[EInvalidOperation |g Classes:: Exception raised when an invalid operation is performed. Obsolete. ]
EInvalidOperation
[EListError |g Classes:: Exception raised when an error occurs in lists handling. ]
EListError
[EMethodNotFound |g Classes:: This exception is no longer used. ]
EMethodNotFound
[EOutOfResources |g Classes:: Exception raised when the system is out of resources. ]
EOutOfResources
[EParserError |g Classes:: Exception raised when an error occurs during the parsing of streams. ]
EParserError
[EReadError |g Classes:: Exception raised if an error occurs while reading from a stream. ]
EReadError
[EResNotFound |g Classes:: Exception raised when a resource, needed to initialize a component, is not found. ]
EResNotFound
[EStreamError |g Classes:: Exception raised when an error occurs during read or write operations on a stream. ]
EStreamError
[EStringListError |g Classes:: Exception raised when an error occurs in a method of TStrings. ]
EStringListError
[EThread |g Classes:: Thread error exception.]
EThread
[EThreadDestroyCalled |g Classes:: Exception raised when a thread is destroyed illegally.]
EThreadDestroyCalled
[EWriteError |g Classes:: Exception raised when an error occurs during writing to a stream. ]
EWriteError
[IStringsAdapter |g Classes:: IStringsAdapter Interface declaration.]
IStringsAdapter
[TAbstractObjectReader |g Classes:: Abstract driver class to read stored component data.]
TAbstractObjectReader
[TAbstractObjectWriter |g Classes:: Abstract driver class for writing component data.]
TAbstractObjectWriter
[TBasicAction |g Classes:: Abstract base class for all Actions.]
TBasicAction
[TBasicActionLink |g Classes:: Link between actions and action clients (e.g. controls)]
TBasicActionLink
[TBinaryObjectReader |g Classes:: Driver class descendent which reads component data stored in binary format.]
TBinaryObjectReader
[TBinaryObjectWriter |g Classes:: Driver class which stores component data in binary form.]
TBinaryObjectWriter
[TBits |g Classes:: Class to store collections of bits (binary values that can be 0 or 1)]
TBits
[TCollection |g Classes:: Base class to manage collections of named objects.]
TCollection
[TCollectionItem |g Classes:: Basic object that is managed by a TCollection class.]
TCollectionItem
[TComponent |g Classes:: Base class for all components that need owner-owned functionality.]
TComponent
[TCustomMemoryStream |g Classes:: Abstract stream that stores its data in memory.]
TCustomMemoryStream
[TDataModule |g Classes:: Container for non-visual components.]
TDataModule
[TFiler |g Classes:: Class responsible for streaming of components.]
TFiler
[TFileStream |g Classes:: Stream that stores its data in a named file on disk.]
TFileStream
[TFPList |g Classes:: Class to manage collections of pointers.]
TFPList
[THandleStream |g Classes:: Base clas for streams that are identified by an OS handle.]
THandleStream
[TList |g Classes:: Class to manage collections of pointers.]
TList
[TMemoryStream |g Classes:: Standard implementation of a stream that stores its data in memory]
TMemoryStream
[TOwnedCollection |g Classes:: TCollection descendent which maintains owner information.]
TOwnedCollection
[TOwnerStream |g Classes:: Stream which uses a second stream as a source]
TOwnerStream
[TParser |g Classes:: Class to parse the contents of a stream containing text data.]
TParser
[TPersistent |g Classes:: Base class for streaming system and persistent properties.]
TPersistent
[TReader |g Classes:: Generic reader object which reads component data from any given source.]
TReader
[TRecall |g Classes:: Helper class for storing published properties]
TRecall
[TResourceStream |g Classes:: Stream that reads its data from a resource object.]
TResourceStream
[TStream |g Classes:: Base class for streams.]
TStream
[TStringList |g Classes:: Standard implementation of the TStrings class.]
TStringList
[TStrings |g Classes:: Class to manage arrays or collections of strings]
TStrings
[TStringStream |g Classes:: Stream that stores its data in a string.]
TStringStream
[TTextObjectWriter |g Classes:: Driver class which stores component data in text format.]
TTextObjectWriter
[TThread |g Classes:: Abstract Thread class.]
TThread
[TThreadList |g Classes:: Thread-safe list object (not yet implemented).]
TThreadList
[TWriter |g Classes:: Object to write component data to an arbitrary format.]
TWriter

[ActivateClassGroup |b Classes:: Activates a class group (TPersistentClass)]
ActivateClassGroup(§|) {? AClass: TPersistentClass} 
[BeginGlobalLoading |b Classes:: Not yet implemented]
BeginGlobalLoading
[BinToHex |b Classes:: Convert a binary buffer to a hexadecimal string]
BinToHex(§|,,) {? BinValue: PChar; HexValue: PChar; BinBufSize: Integer}
[Bounds |b Classes:: Returns a TRect structure with the bounding rect of the given location and size (TRect).]
Bounds(§|,,,) {? ALeft: Integer; ATop: Integer; AWidth: Integer; AHeight: Integer}
[CheckSynchronize |b Classes:: Check whether there are any synchronize calls in the synchronize queue.]
CheckSynchronize(§|) {? timeout: LongInt}
[ClassGroupOf |b Classes:: Returns the class group to which an instance or class belongs (TPersistentClass)]
ClassGroupOf(§|) {? AClass: TPersistentClass|TPersistent}
[CollectionsEqual |b Classes:: Returns True if two collections are equal (Boolean).]
CollectionsEqual(§|,) {? C1: TCollection; C2: TCollection} 
[EndGlobalLoading |b Classes:: Not yet implemented.]
EndGlobalLoading
[FindClass |b Classes:: Returns the class pointer of a class with given name (TPersistentClass).]
FindClass(§|) {? const AClassName: String}
[FindGlobalComponent |b Classes:: Callback used when a component must be found (TComponent).]
FindGlobalComponent(§|) {? const Name: String}
[FindNestedComponent |b Classes:: Finds the component with name path starting at the indicated root component (TComponent).]
FindNestedComponent(§|,) {? Root: TComponent; const NamePath: String}
[GetClass |b Classes:: Returns the class pointer of a class with given name (TPersistentClass)]
GetClass(§|) {? const AClassName: String} 
[GetFixupInstanceNames |b Classes:: Returns the names of elements that need to be resolved for the root component, whose reference contains ReferenceRootName]
GetFixupInstanceNames(§|,,) {? Root: TComponent; const ReferenceRootName: String; Names: TStrings}
[GetFixupReferenceNames |b Classes:: Returns the names of elements that need to be resolved for the root component.]
GetFixupReferenceNames(§|,) {? Root: TComponent; Names: TStrings}
[GlobalFixupReferences |b Classes:: Called to resolve unresolved references after forms are loaded.]
GlobalFixupReferences
[GroupDescendentsWith |b Classes:: Add class to the group of another class.]
GroupDescendentsWith(§|,) {? AClass: TPersistentClass; AClassGroup: TPersistentClass}
[HexToBin |b Classes:: Convert a hexadecimal string to a binary buffer (Integer)]
HexToBin(§|,) {? HexValue: PChar; BinValue: PChar; BinBufSize: Integer}
[IdentToInt |b Classes:: Looks up an integer value in a integer-to-identifier map list (Boolean).]
IdentToInt(§|,) {? const Ident: String; var Int: LongInt; const Map: Array[] of TIdentMapEntry}
[InitComponentRes |b Classes:: Provided for Delphi compatibility only (Boolean)]
InitComponentRes(§|,) {? const ResName: String; Instance: TComponent}
[InitInheritedComponent |b Classes:: Initializes a component descending from RootAncestor (Boolean)]
InitInheritedComponent(§|,) {? Instance: TComponent; RootAncestor: TClass}
[IntToIdent |b Classes:: Looks up an identifier for an integer value in a identifier-to-integer map list (Boolean).]
IntToIdent(§|,,) {? Int: LongInt; var Ident: String; const Map: Array[] of TIdentMapEntry}
[LineStart |b Classes:: Finds the start of a line in Buffer before BufPos (PChar).]
LineStart(§|,) {? Buffer: PChar; BufPos: PChar}
[NotifyGlobalLoading |b Classes:: Not yet implemented.]
NotifyGlobalLoading
[ObjectBinaryToText |b Classes:: Converts an object stream from a binary to a text format.]
ObjectBinaryToText(§|,) {? Input: TStream; Output: TStream}
[ObjectResourceToText |b Classes:: Converts an object stream from a (windows) resource to a text format.]
ObjectResourceToText(§|,) {? Input: TStream; Output: TStream}
[ObjectTextToBinary |b Classes:: Converts an object stream from a text to a binary format.]
ObjectTextToBinary(§|,) {? Input: TStream; Output: TStream}
[ObjectTextToResource |b Classes:: Converts an object stream from a text to a (windows) resource format.]
ObjectTextToResource(§|,) {? Input: TStream; Output: TStream}
[Point |b Classes:: Returns a TPoint record with the given coordinates (TPoint).]
Point(§|,) {? AX: Integer; AY: Integer}
[ReadComponentRes |b Classes:: Read component properties from a resource in the current module(TComponent)]
ReadComponentRes(§|,) {? const ResName: String; Instance: TComponent}
[ReadComponentResEx |b Classes:: Read component properties from a resource in the specified module (TComponent)]
ReadComponentResEx(§|,) {? HInstance: THandle; const ResName: String}
[ReadComponentResFile |b Classes:: Read component properties from a specified resource file (TComponent)]
ReadComponentResFile(§|,) {? const FileName: String; Instance: TComponent}
[Rect |b Classes:: Returns a TRect record with the given coordinates (TRect).]
Rect(§|,,,) {? ALeft: Integer; ATop: Integer; ARight: Integer; ABottom: Integer}
[RedirectFixupReferences |b Classes:: Redirects references under the root object from OldRootName to NewRootName]
RedirectFixupReferences(§|,,) {? Root: TComponent; const OldRootName: String; const NewRootName: String}
[RegisterClass |b Classes:: Registers a class with the streaming system.]
RegisterClass(§|) {? AClass: TPersistentClass}
[RegisterClassAlias |b Classes:: Registers a class alias with the streaming system.]
RegisterClassAlias(§|,) {? AClass: TPersistentClass; const Alias: String}
[RegisterClasses |b Classes:: Registers multiple classes with the streaming system.]
RegisterClasses(§|) {? AClasses: Array[] of TPersistentClass}
[RegisterComponents |b Classes:: Registers components for the component palette.]
RegisterComponents(§|,) {? const Page: String; ComponentClasses: Array[] of TComponentClass}
[RegisterFindGlobalComponentProc |b Classes:: Register a component searching handler]
RegisterFindGlobalComponentProc(§|) {? AFindGlobalComponent: TFindGlobalComponent}
[RegisterInitComponentHandler |b Classes:: Register a component initialization handler]
RegisterInitComponentHandler(§|,) {? ComponentClass: TComponentClass; Handler: TInitComponentHandler}
[RegisterIntegerConsts |b Classes:: Registers some integer-to-identifier mappings.]
RegisterIntegerConsts(§|,,) {? IntegerType: Pointer; IdentToIntFn: TIdentToInt; IntToIdentFn: TIntToIdent}
[RegisterNoIcon |b Classes:: Registers components that have no icon on the component palette.]
RegisterNoIcon(§|) {? ComponentClasses: Array[] of TComponentClass}
[RegisterNonActiveX |b Classes:: Register non-activex component.]
RegisterNonActiveX(§|,) {? ComponentClasses: Array[] of TComponentClass; AxRegType: TActiveXRegType}
[RemoveFixupReferences |b Classes:: Removes references to rootname from the fixup list.]
RemoveFixupReferences(§|,) {? Root: TComponent; const RootName: String}
[RemoveFixups |b Classes:: Removes Instance from the fixup list.]
RemoveFixups(§|) {? Instance: TPersistent}
[SmallPoint |b Classes:: Returns a TSmallPoint record with the given coordinates (TSmallPoint).]
SmallPoint(§|,) {? AX: SmallInt; AY: SmallInt}
[StartClassGroup |b Classes:: Start new class group.]
StartClassGroup(§|) {? AClass: TPersistentClass}
[UnRegisterClass |b Classes:: Unregisters a class from the streaming system.]
UnRegisterClass(§|) {? AClass: TPersistentClass}
[UnRegisterClasses |b Classes:: Unregisters multiple classes from the streaming system.]
UnRegisterClasses(§|) {? AClasses: Array[] of TPersistentClass}
[UnregisterFindGlobalComponentProc |b Classes:: Remove a previously registered component searching handler.]
UnregisterFindGlobalComponentProc(§|) {? AFindGlobalComponent: TFindGlobalComponent}
[UnRegisterModuleClasses |b Classes:: Unregisters classes registered by module.]
UnRegisterModuleClasses(§|) {? Module: HModule}
[WriteComponentResFile |b Classes:: Write component properties to a specified resource file]
WriteComponentResFile(§|,) {? const FileName: String; Instance: TComponent}

[AddDataModule |f Classes:: Handler called when a new TDataModule instance is created.]
AddDataModule
[ApplicationHandleException |f Classes:: Handler for exceptions when a TDataModule streaming error occurs.]
ApplicationHandleException
[ApplicationShowException |f Classes:: Unused.]
ApplicationShowException
[MainThreadID |f Classes:: ID of main thread. Unused at this point.]
MainThreadID
[RegisterComponentsProc |f Classes:: Callback procedure used when handling component registration.]
RegisterComponentsProc
[RegisterNoIconProc |f Classes:: Callback procedure used when handling iconless component registration.]
RegisterNoIconProc
[RemoveDataModule |f Classes:: Handler called when a TDataModule instance is freed.]
RemoveDataModule
[WakeMainThread |f Classes:: Handler which is called if a thread wants to synchronize with the main application thread.]
WakeMainThread

